#!D:/Perl/bin/perl.exe -T
##
my $VERSION = 20010222;
use CGI qw( -no_debug -newstyle_urls :standard escapeHTML escape);
use CGI::Carp 'fatalsToBrowser';
$| = 1; use strict; use integer; # use 5.005; I used 5.005... not certain of min req
use Data::Dumper; $Data::Dumper::Indent = 1;
use Time::Seconds;
use Win32::AdminMisc;
use Win32;
use Win32::OLE;
use Win32::OLE::Enum;
use Win32::OLE::Variant;


# POD added at the last minute per
	# http://www.cpan.org/scripts/submitting.html

=head1 NAME

adsibrowser - cgi script browses ActiveDirectory via the web

=head1 DESCRIPTION

this is basically a learning excersize for me to wrap my head
around adsi and what it makes available. When I started there
wasn't much out there on perl and ADSI (aside from TE's perl/Tk
adsi browser for which I had not the Tk) so I thought other
folks might be interested in the code, rough as it is.

=head1 README

install cgi script, pull it up in your web browser, pick a
level of detail and starting point, view ADSI objects, their
property values, available methods/properties, implemented
interfaces. Click links to see more.

=head1 PREREQUISITES

ADSI must be installed on the web server
    http://www.microsoft.com/adsi

Perl modules:
	CGI
	CGI::Carp
	Data::Dumper
	Time::Seconds
	Win32::AdminMisc
	Win32
	Win32::OLE
	Win32::OLE::Enum
	Win32::OLE::Variant

=head1 COREQUISITES

none

=pod OSNAMES

winNT (developed on NT4, I think Win2K might work too)

=pod SCRIPT CATEGORIES

Win32

=pod CHANGES

20010127

	first release

20010222

	fixed broken "custom path" feature.
	I'd added that at the last minute before uploading, and neglected to
	test it (or even use it). As I said, this code is just gathering dust
	on my end. I'm glad "A.C." has some use for it and spotted the bug too.

=cut




##
# script to browse adsi hierarchies (read only) via the web
# writen as an exercise to learn about adsi, and eventually to be a useful tool
# the script's documentation is nearly non-existant
# 
# released into the public domain by the author (matthew wickline) Jan 26 2001
##
# DO NOT install this script w/o restricting access to those who should have it.
# DO NOT install this script unless you accept full liability for any and all
# consequences, direct and indirect, of the script's use. It's good enough for
# what I want it to do, but you need to verify for yourself that it doesn't
# pose any sort of risk for you.
##
# I've got .plt mapped on my webserver to run perl -T
# You may want to remove the -T up there, and/or change the filename.
##
# This is not polished. At all. This is the first ADSI, or even OLE thing
# that I've done. It's hugely sluggish, inneficient, etc... it's a work in
# progress. I don't know when/if I'll do more with it, but thought I would
# put this out in the public for folks to chew on since it did have some
# code folks might be able to adapt to their needs. Note that I've only got
# the winnt namespace (as avail in NT4) to play with, so any of those other
# namespaces are given no attention in the code that follows. In my world,
# the LDAP and IIS namespaces are leaf nodes... no objects within.
##
# I've stripped out a bunch references to site-specific modules that handle
# errors, logging, page look-and-feel, etc. A bit of the code's problems are
# due to less-than-ideal substitutions as I try to get something together
# that will work elsewhere. Hopefully you now just need perl and ADSI.
# (and some modules that I think come with activeperl by default)
#   perl: http://www.activestate.com/Products/ActivePerl/
#   adsi: http://www.microsoft.com/adsi
# Oh! I think Time::Seconds is *not* standard...
#   cpan: http://search.cpan.org/search?mode=module&query=time%3A%3Aseconds
# Hopefully I didn't miss any problems after excising the site-specific code
##
# Credits:
# 
# Toby Everett http://opensource.activestate.com/authors/tobyeverett/
# I used his interface data before I broke down and parsed my own.
# His emails also helped me wrap my head around a few issues.
# 
# http://www.asptoday.com/articles/19990310.htm
# Alerted me to the lanmanserver issue (search for 'lanmanserver' below).
##

my $groups_members_as_properties = 1;
	# Users have a method 'Groups' which tells you what groups they're in
	# Groups have a method 'Members' which tells you what users they have
	# There didn't seem to be many other methods that were very usefull in
	# read only sense, so set the above flag to treat those two methods as
	# properties, for the purposes of this script.
my $live_version = 0;
	# developmental version ($live=0) uses Data::Dumper to show some stuff
	# live version has less cluttered output


# repeat var names to avoid spurious 'used once' warning
$CGI::DISABLE_UPLOADS = $CGI::DISABLE_UPLOADS = 1;
$CGI::POST_MAX = $CGI::POST_MAX = 1024*1024*.25; # .25Mb is plenty
&set_title( 'ADSI Browser' );
&set_heading( 'an ADSI browser, perl implementation, CGI interface' );
&bail_out( q[you probably don't want the general public running this (line ].__LINE__.')' )
	unless $ENV{'REMOTE_USER'};
my %cache; # will be filled as things are looked up
	# need to tie to disk, speed up script quite a bit
	# if this script is ever used for "real" stuff, need to worry about stale data
$cache{'primary_interface'} = {
	'Schema' => 'IADs',
	'Namespace' => 'IADsNamespaces',
	map {($_ => "IADs$_")} qw{Class Syntax Property Namespaces},
};
my %param = CGI::Vars();
if ( $live_version and !exists $param{'reduced_interface'} ) {
	$param{'reduced_interface'} = 1; # default for non-dev
}
if ( exists $param{'path'} and $param{'path'} eq '*' ) {
	# user indicated that they want to start at their own path
	$param{'path'} = $param{'custom_path'};
	param(  '-name'  => 'path',  '-value' => $param{'custom_path'}  );
}
my @info; # sorted list of keys below. to re-sort, drag-n-drop the code chunks
my %info = ( # idsip = info display
	do{push(@info,'idisp_contained_objects');$info[-1]} => {
		'hidden' => 0,
		'desc' => q{list any objects contained by the node (takes a while if the node is a domain or a computer)},
		'indent' => 0,
		'checked' => 0,
		'display' => \&idisp_contained_objects,
	},
	do{push(@info,'idisp_interface_hierarchy');$info[-1]} => {
		'hidden' => $param{'reduced_interface'},
		'desc' => q{list the interfaces supported by the object},
		'indent' => 0,
		'checked' => 1,
		'display' => \&idisp_interface_hierarchy,
	},
	do{push(@info,'idisp_interface_details');$info[-1]} => {
		'hidden' => $param{'reduced_interface'},
		'desc' => q{describe the interfaces in more detail},
		'indent' => 1,
		'checked' => 0,
		'display' => \&idisp_interface_details,
	},
	do{push(@info,'idisp_property_declarations');$info[-1]} => {
		'hidden' => $param{'reduced_interface'},
		'desc' => q{describe the properties applicable to the object},
		'indent' => 0,
		'checked' => 1,
		'display' => \&idisp_property_declarations,
	},
	do{push(@info,'idisp_property_values');$info[-1]} => {
		'hidden' => 0,
		'desc' => q{list the object's properties' values (and other details)},
		'indent' => !$param{'reduced_interface'},
		'checked' => $param{'reduced_interface'},
		'display' => \&idisp_property_values,
	},
	do{push(@info,'idisp_method_declarations');$info[-1]} => {
		'hidden' => $param{'reduced_interface'},
		'desc' => q{describe the methods applicable to the object},
		'indent' => 0,
		'checked' => 1,
		'display' => \&idisp_method_declarations,
	},
	do{push(@info,'idisp_safe_method_values');$info[-1]} => {
		'hidden' => 0,
		'desc' => q{list the values of 'psuedoproperty' methods (best with user and group objects)},
		'indent' => !$param{'reduced_interface'},
		'checked' => 0,
		'display' => ( $groups_members_as_properties ? undef : \&idisp_safe_method_values ),
	},
	do{push(@info,'idisp_tlb_data');$info[-1]} => {
		'hidden' => $param{'reduced_interface'},
		'desc' => q{dump all data currently parsed from type lib (takes a while)},
		'indent' => 0,
		'checked' => 0,
		'display' => \&idisp_tlb_data,
	},
);
@info = grep {
	$info{$_}{'display'} # must be capable of rendering itself
	and # mustn't be hidden by reduced interface preference
	( $param{'reduced_interface'} ? !$info{$_}{'hidden'} : 1 )
} @info;


my $nothing_checked_alert;
my $number_checked = grep { exists($param{$_}) and $param{$_} } @info;
unless ( $number_checked ) {
	if ( exists $param{'path'} ) {
		$nothing_checked_alert
			= q{<font color="#FF3300">None of these were checked, so I'll help you out...</font><br>};
	}
	$param{$_}++ for (grep {$info{$_}{'checked'}} @info)
}
my $adsobj;
my $no_object_alert = '';
if (  $param{'path'} and length($param{'path'})  ) {
	$param{'path'} =~ m/^([\s\S]+)$/;
	$param{'path'} = $1; # untainted, bad data will fail in next line:
	$param{'path'} =~ s{^([^:]+:),[^,]+$}{$1}; # bad to call a namespace what it is
	unless (  $adsobj = &get_adsi_object_from_path( $param{'path'} )  ) {
		$no_object_alert
			= strong('<font color="#FF0000">Requested Object Not Found!</font>');
	}
}
if (  $no_object_alert  or  !( $param{'path'} and length $param{'path'} )  ) {
	# bogus request, or new session: give them some good starting points...
	my $local_node = Win32::NodeName() or &bail_out(
		"NodeName() failed: $^E  (line ".__LINE__.')',
	);
	my $domain = Win32::DomainName() or &bail_out(
		"DomainName() failed: $^E  (line ".__LINE__.')',
	);
	my $pdc_node = Win32::AdminMisc::GetPDC($domain) or &bail_out(
		"GetPDC() failed: $^E  (line ".__LINE__.')',
	);
	$pdc_node =~ s{^\\\\}{};
	my $local_user = Win32::LoginName() or &bail_out(
		"LoginName() failed: $^E  (line ".__LINE__.')',
	);
	my $found_path = '';
	print header, get_html_header(), (
		$no_object_alert,
		start_form(
			'-action' => url(),
			'-method' => 'GET',
		),
		dl(
			dt( q{Choose the information you would like to view:} ),
				dd( &config_view_prefs_for_path() ),
			dt( q{<br>Choose a starting point:<br><small>(derived from current environment)</small>} ),
				dd(join( '<br><br>',
					(
						map { join( '',
							escapeHTML( $_->{'desc'} ),
							q{<br>&#160;&#160;&#160;&#160;&#160;&#160;},
							qq{<input type="radio" name="path" value="},
							escapeHTML( $_->{'path'} ),
							(
								($param{'path'} eq $_->{'path'} and !$found_path)
									? $found_path = q{" checked}
									: q{"}
							),
							q{>&#160;<code>},
							escapeHTML( $_->{'path'} ),
							q{</code>},
						)} (
							{
								'path' => q{ADs:},
								'desc' => q{root node of the ActiveDirectory hierarchy},
							},{
								'path' => qq{WinNT://$domain,domain},
								'desc' => q{node representing the current domain},
							},{
								'path' => qq{WinNT://$domain/$local_user,user},
								'desc' => q{node representing the current user},
							},{
								'path' => qq{WinNT://$domain/$local_node,computer},
								'desc' => q{node representing this webserver },
							},{
								'path' => qq{WinNT://$domain/$pdc_node,computer},
								'desc' => q{node representing that domain's PDC},
							},
						)
					),
					join( '',
						q{node represented by a path of your choice:},
						q{<br>&#160;&#160;&#160;&#160;&#160;&#160;},
						q{<input type="radio" name="path" value="*"},
						( exists $param{'path'} and $param{'path'} eq '*'
							? ' checked' : ''
						),
						q{>&#160;},
						textfield(
							'-name' => 'custom_path',
							'-size' => 50,
							'-maxlength' => 5000,
						),
					),
				)),
			dt( q{<br>Save view preferences and...} ),
				dd(  submit( '-value' => 'View Selected Node' )  ),
		),
		end_form(), end_html(),
	);
	exit();
} # else...
# good request, act on it:
my $interfaces;
my $uuid;
&set_tlb_info(); # sets the above two hashrefs will all their goodies
&approve_methods_as_psuedoproperties();
&set_title(  'Browsing ' . escapeHTML( $param{'path'} )  );
&set_heading(  'ADSI Path ' . &all_partial_links_for_path( $param{'path'} )  );
print header, &get_html_header(), join( '<br><br>',
	config_view_prefs_for_path( $param{'path'} ),
	map { $param{$_}
		? &{ $info{$_}{'display'} }( $adsobj )
		: ()
	} @info
), end_html();
exit();



sub bail_out {
	&set_title( 'Error!' );
	&set_heading( $_[0] );
	print header &get_html_header(), p(q{ Please try again later. }), end_html();
	exit();
}

{
	my $web_page_title;
	my $web_page_heading;
	my $web_page_html_header;
	sub get_html_header {
		$web_page_html_header
	}
	sub set_heading {
		$web_page_html_header = start_html($web_page_title).strong($_[0])
	}
	sub set_title {
		$web_page_html_header = start_html($_[0]).strong($web_page_heading)
	}
}


sub info_link_for_path {
	# given ads path, create href to link to path with current info settings
	return escapeHTML join( '',
		url(),
		'?',
		join( ';',
			'path=' . &escape($_[0]),
			(
				map {
					&escape($_) . "=" . &escape($_[0])
				} keys %info, 'reduced_interface'
			),
		),
	);
}


sub all_partial_links_for_path {
	# return a string with links to all partial paths
	# only arg is adspath
	my $adspath = shift;
	my $adsobj;
	unless (
		$adspath =~m/^([^:]+:.*?)(?:,([^,]+))?$/
		and $adsobj = &get_adsi_object_from_path( $adspath )
	) {
		return escapeHTML($adspath);
	}
	my($path, $class) = (  $1,  $adsobj->{'Class'} || $2  );
	my $partial_path = '';
	my $return = '<a href="'.&info_link_for_path($adspath).'">'.escapeHTML($path).'</a>';
	if ( $path =~ m{^(([^:]+:)//([^/]+))(?:/(.+))?} ) {
		$return = join( '',
			'<a href="',&info_link_for_path( $2 ),'">',escapeHTML( $2 ),'</a>',
			'//&#160;',
			'<a href="',&info_link_for_path( $1 ),'">',escapeHTML( $3 ),'</a>',
		);
		$partial_path = $1;
		for my $piece (  $4 ? split('/', $4) : ()  ) {
			$partial_path .= '/'.$piece;
			$return .= '/&#160;<a href="'
				. &info_link_for_path($partial_path)
				. q'">'
				. escapeHTML($piece)
				. '</a>'
			;
		}
	}
	return $return . ( $class
		? ',&#160;' . &get_class_link($adsobj)
		: ''
	);
}


sub get_class_link {
	# tries to return link to class of the adsobj at a given path
	# only arg is adsobj
	my $class_schema = &get_class_schema( $_[0] );
	unless ( $class_schema ) {
		return escapeHTML( $_[0]->{'Class'} )
	}
	return join( '',
		'<a href="',
		&info_link_for_path(  $class_schema->{'ADsPath'}.','.$class_schema->{'Class'}  ),
		q'">',
		$_[0]->{'Class'},
		'</a>',
	);
}


sub get_property_or_syntax_link {
	# tries to return link to property, or just that property
	# only arg is a string... maybe a an adspath, maybe a property name
	my $adsi_object = &get_adsi_object_from_path( $_[0] );
	return( $adsi_object
		? join( '',
			'<a href="',
			&info_link_for_path( $_[0] ),
			'">',
			escapeHTML( $adsi_object->{'Name'} ),
			'</a>',
		)
		: escapeHTML( $_[0] )
	);
}




sub config_view_prefs_for_path {
	# return form to turn on/off display of certain items
	# only arg is typically an ads path
	# if arg not defined, that means we return
	# just the checkboxes, not the whole form
	my $path = shift; # only arg is an adsi path
	return join( '',
		(
			!defined $path ? '' : start_form(
				'-action' => url(),
				'-method' => 'GET',
			)
		),
		( !defined $path ? () : (
			'<select name="reduced_interface">',
			( $param{'reduced_interface'}
				? ( '<option value="1" selected>'
						=> 'Currently hiding less-used checkboxes</option>',
					'<option value="0">'
						=> 'Switch to a complete list of checkboxes</option>',
				)
				: ( '<option value="0" selected>'
						=> 'Currently all checkboxes are available</option>',
					'<option value="1">'
						=> 'Switch to a leaner list of checkboxes</option>',
				)
			),
			'</select><br>',
		)),
		$nothing_checked_alert,
		'<small>',
		(
			map {(
				'&#160;&#160;&#160;&#160;' x $info{$_}{'indent'},
				qq{<input type="checkbox" name="$_" value="1"},
				( $param{$_} ? ' checked' : '' ),
				'>&#160;',
				( $path and $param{$_} and $number_checked > 1
					? qq{ (<a href="#$_">goto</a>)&#160;} : ''
				),
				escapeHTML( $info{$_}{'desc'} ),
				'<br>',
			)} @info
		),
		'</small>',
		(
			map {(
				qq{<input type="hidden" name="$_" value="$param{$_}">},
			)} grep { # possible to display, but currently hidden
				$info{$_}{'display'} and $info{$_}{'hidden'}
			} keys %info
		),
		(
			!defined $path ? '' : (
				hidden(  '-value' => $path, '-name' => 'path',  ),
				submit(  '-value' => 'Save Settings and Refresh View',  ),
				' <small>(unsaved settings are ignored)</small>',
				end_form(),
			)
		),
	);
}




sub get_adsi_object_from_path {
	my $path = shift; # only arg is an adsi path
	unless ( exists ${ $cache{'object'} }{$path} ) {
		${ $cache{'object'} }{$path} = Win32::OLE->GetObject( $path );
	}
	return ${ $cache{'object'} }{$path};
}


sub get_schema {
	# only arg is an adsi object
	if (  exists ${ $cache{'schema'} }{ $_[0]->{'AdsPath'} }  ) {
		return(  ${ $cache{'schema'} }{ $_[0]->{'AdsPath'} }  );
	}
	my $class_schema = &get_class_schema( $_[0] );
	if ( $class_schema ) {
		my $schema = $class_schema->{'Parent'};
		if ($schema and
			$schema = &get_adsi_object_from_path( $class_schema->{'Parent'} )
		) {
			return(  ${ $cache{'schema'} }{ $_[0]->{'AdsPath'} } = $schema  );
		}
	}
	# no schema found yet... see if we can guess it:
	if (  $_[0]->{'AdsPath'} =~ m{^(WinNT://[^/,]+)}  ) {
		# cache a guess if we don't have one yet... (guess may even be undef)
		unless ( exists ${ $cache{'schema'} }{' default  '}{$1} ) {
			${ $cache{'schema'} }{' default  '}{$1}
				= &get_adsi_object_from_path( qq{$1/Schema,Schema} );
		}
		return (
			${ $cache{'schema'} }{ $_[0]->{'AdsPath'} }
				= ${ $cache{'schema'} }{' default  '}{$1}
		);
	} else {
		my $domain = Win32::DomainName() or &bail_out(
			"DomainName() failed: $^E  (line ".__LINE__.')',
		);
		unless ( exists ${ $cache{'schema'} }{' default  '}{$domain} ) {
			${ $cache{'schema'} }{' default  '}{$domain}
				= &get_adsi_object_from_path( qq{WinNT://$domain/Schema,Schema} );
		}
		return (
			${ $cache{'schema'} }{ $_[0]->{'AdsPath'} }
				= ${ $cache{'schema'} }{' default  '}{$domain}
		);
	}
	# drats... we failed :(
	return undef;
}


sub get_class_schema {
	# only arg is an adsi object
	if (  exists ${ $cache{'class_schema'} }{ $_[0]->{'AdsPath'} }  ) {
		return(  ${ $cache{'class_schema'} }{ $_[0]->{'AdsPath'} }  );
	}
	my $class_schema = $_[0]->{'Schema'};
	if ($class_schema and
		$class_schema = &get_adsi_object_from_path( $_[0]->{'Schema'}.',Class' )
	) {
		return(  ${ $cache{'class_schema'} }{ $_[0]->{'AdsPath'} } = $class_schema  );
	}
	# no class schema found yet... see if we can guess it:
	if (  $_[0]->{'AdsPath'} =~ m{^(WinNT://[^/,]+)}  ) {
		# cache a guess if we don't have one yet... (guess may even be undef)
		my $guess_path = $1.'/Schema/'.$_[0]->{'Class'}.',Class';
		unless ( exists ${ $cache{'class_schema'} }{' default  '}{$guess_path} ) {
			 ${ $cache{'class_schema'} }{' default  '}{$guess_path}
			 	= &get_adsi_object_from_path( $guess_path );
		}
		return (
			${ $cache{'class_schema'} }{ $_[0]->{'AdsPath'} }
				= ${ $cache{'class_schema'} }{' default  '}{$guess_path}
		);
	}
	# drats... we failed :(
	return undef;
}


sub get_primary_interface {
	# only arg is an adsi object
	if (  exists ${ $cache{'primary_interface'} }{ $_[0]->{'Class'} }  ) {
		return(  ${ $cache{'primary_interface'} }{ $_[0]->{'Class'} }  );
	}
	my $p_interface ;
	my $class_schema;
	if ( $class_schema = &get_class_schema( $_[0] )  ) {
		( $p_interface = $class_schema->{'PrimaryInterface'} ) =~ s/[\{\}]//g;
		$p_interface = $uuid->{ $p_interface };
	}
	unless ( $p_interface ) {
		# what the hell... just try everything we know about
		unless (  exists ${ $interfaces }{'__uber_interface__'}  ) {
			$interfaces->{'__uber_interface__'}{'isa'} = [keys %$interfaces];
		}
		$p_interface = '__uber_interface__';
	}
	return ${ $cache{'primary_interface'} }{ $_[0]->{'Class'} } = $p_interface;
}




sub idisp_contained_objects {
	# return a view of what stuff might be inside an adsi object
	# only arg is an adsi object
	return &pretty_value_contained_objects($_[0]);
	# had to extract this code for other subs to use... ah well...
}


sub idisp_interface_hierarchy {
	my @isa = reverse @{  $interfaces->{ &get_primary_interface($_[0]) }{'isa'}  };
	my $return = join( '',
		h2(q{<a name="idisp_interface_hierarchy">Supported Interfaces:</a>}),
		shift(@isa),
		'<br>',
	);
	my $indent;
	for my $i ( @isa ) {
		$return .= join( '',
			'<tt>',
			'&#160;&#160;&#160;&#160;' x $indent++,
			'`--></tt>',
			escapeHTML($i),
		);
		my @things;
		if (  exists ${ $interfaces->{$i} }{'methods'}  ) {
			push( @things,
				scalar(  keys %{ $interfaces->{$i}{'methods'} }  )
				. ' ' . (
					keys %{ $interfaces->{$i}{'methods'} } == 1
						? 'method'
						: 'methods'
				)
			);
		}
		if (  exists ${ $interfaces->{$i} }{'properties'}  ) {
			push( @things,
				scalar(  keys %{ $interfaces->{$i}{'properties'} }  )
				. ' ' . (
					keys %{ $interfaces->{$i}{'properties'} } == 1
						? 'property'
						: 'properties'
				)
			);
		}
		$return .= !@things ? '<br>'
			: ' <small>(provides ' . join( ' and ', @things ) . ')</small><br>';
	}
	return $return;
}


sub idisp_interface_details {
	my @isa = @{  $interfaces->{ &get_primary_interface($_[0]) }{'isa'}  };
	my $return = join( '',
		h2(qq{<a name="idisp_interface_details">Interface Details:</a>}),
		'<table border="0" cellpadding="4" cellspacing="0">',
		'<tr align="left" valign="top">',
		(  map {'<th>'.escapeHTML($_).'<hr noshade></th>'} @isa  ),
		'</tr><tr align="left" valign="top">',
	);
	for my $i ( @isa ) {
		my @methods = ( exists ${ $interfaces->{$i} }{'methods'}
			? sort keys %{ $interfaces->{$i}{'methods'} }
			: ()
		);
		my @properties = ( exists ${ $interfaces->{$i} }{'properties'}
			? sort keys %{ $interfaces->{$i}{'properties'} }
			: ()
		);
		$return .= td(
			'<dl>',
			'<dt><br>Methods:', (  !@methods ? 'none</dt>' :(
				'<dt>',
				'<dd><code>',
				( 
					map {
						exists ${ $interfaces->{$i}{'methods'}{$_} }{'args'}
							? escapeHTML($_).'()<br>'
							: escapeHTML($_).'<br>'
					} @methods
				),
				'</code></dd>',
			)),
			'<dt><br>Properties:', (  !@properties ? 'none</dt>' :(
				'<dt>',
				'<dd><code>',
				( 
					map {
						exists ${ $interfaces->{$i}{'properties'}{$_} }{'set'}
							? escapeHTML($_).'()<br>'
							: escapeHTML($_).'<br>'
					} @properties
				),
				'</code></dd>',
			)),
			'</dl>',
		);
	}
	return $return.'</tr></table>';
}


sub idisp_property_declarations {
	my @isa = @{  $interfaces->{ &get_primary_interface($_[0]) }{'isa'}  };
	my %props;
	for my $i ( @isa ) {
		next unless exists ${ $interfaces->{$i} }{'properties'};
		$props{$_} = $interfaces->{$i}{'properties'}{$_}
			for keys %{ $interfaces->{$i}{'properties'} };
	}
	return join( '',
		h2(qq{<a name="idisp_property_declarations">Property Descriptions:</a>}),
		'(only lists interface-defined properties, ',
		'not schema-defined mandatory and optional properties)<br>',
		'<table border="1" cellpadding="3" cellspacing="0">',
		'<tr align="left" valign="top">',
		(
			map {'<th>'.escapeHTML($_).'</th>'}
			('property', 'set with', 'get() returns',)
		),
		'</tr>',
		(
			map { my $p = $_;
				'<tr align="left" valign="top">',
				td(escapeHTML( $p )),
				td(join( '<br>',
					(exists ${ $props{$p} }{'set'} and
					exists ${ $props{$p}{'set'} }{'args'})
						? map { code(escapeHTML($_)) } @{ $props{$p}{'set'}{'args'} }
						: (' &#160; ')
				)),
				td(join( '<br>',
					(exists ${ $props{$p} }{'get'} and
					exists ${ $props{$p}{'get'} }{'returns'})
						? map { code(escapeHTML($_)) } @{ $props{$p}{'get'}{'returns'} }
						: (' &#160; ')
				)),
				'</tr>',
			} sort keys %props
		),
		'</table>',
	);
}

sub idisp_property_values {
	# return a view of object's properties
	# only arg is an adsi object
	my $properties = &get_property_hashes( $_[0] );
	my $property_s = scalar( keys %$properties ) == 1 ? 'Property' : 'Properties';
	# three keys in this next thing match up with labels
	# given in get_property_hashes so don't get them out of sync
	my %reqd_indicators = (
		# this is how we mark and color our property rows:
		'Mandatory'   => {
			'marker' => 'y',
			'colors' => [qw( #FFDDDD #FFC8CC )], #    red
		},
		'Optional'   => {
			'marker' => 'n',
			'colors' => [qw( #DDFFDD #C8FFCC )], #  green
		},
		'Unknown'   => {
			'marker' => '?',
			'colors' => [qw( #FFFFDD #FFFFCC )], # yellow
		},
		'IADs'   => {
			'marker' => '-',
			'colors' => [qw( #F7F7F7 #EFEFEF )], # ltgray
		},
# 			'colors' => [qw( #FFDDFF #FFC8FF )], #   blue
# 			'colors' => [qw( #DDDDFF #C8C8FF )], # purple
# 			'colors' => [qw( #FFDDFF #FFC8FF )], #  lilac
# 			'colors' => [qw( #DDDDDD #C8C8C8 )], #   gray
	);
	my $even_row = 0;
	unless ( keys %$properties ) {
		return h2(
			qq{<a name="idisp_property_values">Object Contains no Properties!</a>)'}
		);
	}
	my $return = join( '',
		h2(
			qq{<a name="idisp_property_values">}
			. scalar( keys %$properties ),
			$property_s.':</a>',
		),
		'<table border="0" cellpadding="0" cellspacing="0">',
		'<tr valign="bottom">',
		'<th align="left">Rqd<hr noshade width="99%" align="left"></th>',
		'<th align="right">Type<hr noshade width="99%" align="left"></th>',
		'<th align="right">Name<hr noshade width="99%" align="left"></th>',
		'<th align="center">&#160;=&#160;<hr noshade width="99%" align="left"></th>',
		'<th align="left">Value<hr noshade width="99%" align="left"></th>',
		( !$live_version
			? '<th align="left">Notes<hr noshade width="99%" align="left"></th>'
			: ()
		),
		'</tr>',
	);
	for (
		sort {  $a->[1] cmp $b->[1]  }
		map  {  [ $_, lc($_) ]  }
		keys %$properties
	) {
		my $p_name = $_->[0];
		$return .= join( '',
			'<tr valign="top" bgcolor="',
			$reqd_indicators{ $properties->{$p_name}{'reqd'} }{'colors'}[$even_row ^= 1],
			'">',
			'<td align="center">',
			'<small>',
			escapeHTML(  $reqd_indicators{ $properties->{$p_name}{'reqd'} }{'marker'}  ),
			'</small></td>',
			'<td align="right">',
			'<small><small>',
			$properties->{$p_name}{'syntax'},
			'&#160;&#160;</small></small></td>',
			'<td align="right"><small>',
			$properties->{$p_name}{'property'},
			'</small></td><td align="center"><small>=</small></td>',
			'<td align="left"><small>',
			$properties->{$p_name}{'value'},
			'</small></td>',
			( !$live_version ?(
				'<td align="left"><small>',
				$properties->{$p_name}{'notes'},
				'</small></td>',
				
			):()),
			'</tr>',
		);
	}
	return $return . '</table><br><br>';
}


sub idisp_method_declarations {
	my @isa = @{  $interfaces->{ &get_primary_interface($_[0]) }{'isa'}  };
	my %methods;
	for my $i ( @isa ) {
		next unless exists ${ $interfaces->{$i} }{'methods'};
		$methods{$_} = $interfaces->{$i}{'methods'}{$_}
			for keys %{ $interfaces->{$i}{'methods'} };
	}
	return join( '',
		h2(qq{<a name="idisp_method_declarations">Method Descriptions:</a>}),
		'<table border="1" cellpadding="3" cellspacing="0">',
		'<tr align="left" valign="top">',
		(
			map {'<th>'.escapeHTML($_).'</th>'}
			qw(method args returns notes)
		),
		'</tr>',
		(
			map { my $m = $_;
				'<tr align="left" valign="top">',
				td(escapeHTML( $m )),
				td(join( '<br>', exists ${ $methods{$m} }{'args'}
					? ol(li([
						map { code(escapeHTML($_)) } @{ $methods{$m}{'args'} }
					]))
					: (' &#160; ')
				)),
				td(join( '<br>', exists ${ $methods{$m} }{'returns'}
					? ol(li([
						map { code(escapeHTML($_)) } @{ $methods{$m}{'returns'} }
					]))
					: (' &#160; ')
				)),
				td(join( '<br>',
					( exists ${ $methods{$m} }{'calling_convention'}
						? code(escapeHTML(  ${ $methods{$m} }{'calling_convention'}  ))
						: (' &#160; ')
					),
				)),
				'</tr>',
			} sort keys %methods
		),
		'</table>',
	);
}

sub idisp_safe_method_values {
	my $p_interface = &get_primary_interface( $_[0] );
	my %methods;
	for my $i (  @{ $interfaces->{$p_interface}{'isa'} }  ) {
		@methods{
			grep { $interfaces->{$i}{'methods'}{$_}{'psuedoproperty'}
			} keys %{ $interfaces->{$i}{'methods'} }
		} = ();
	}	
	my $methhod_s = scalar( keys %methods ) == 1 ? 'Method' : 'Methods';
	unless ( keys %methods ) {
		return h2(
			qq{<a name="idisp_safe_method_values">Contains no Property-like Methods!</a>}
		);
	}
	# need to pre-process data to render it attractively
	# need to extract rendering code from get_property_hashes to share here
	# this will simplify $quiet in idisp_contained_objects
	my $return = join( '',
		h2(
			qq{<a name="idisp_safe_method_values">}
			. scalar( keys %methods ),
			' Property-like ',
			$methhod_s.':</a>',
		),
		'<table border="1" cellpadding="3" cellspacing="0">',
		(
			map {
				my $m_name = $_;
				my $value = $_[0]->{$m_name};
				my $default_display = pre(   escapeHTML(  &Dumper( $value )  )   );
				my $display;
				if (  ref $value  and  ref $value eq 'Win32::OLE'  ) {
					$display = &pretty_value_contained_objects( $value )
				} elsif ( !defined($value) or !length($value) ) {
					$display = '&#160;';
				} else {
					$display = qq{<font color="#FF0000">$default_display</font>};
				}
				(
					'<tr valign="top"><td align="right">',
					$m_name,
					'</td><td align="left">',
					$display,
					( $live_version ? '' : "</td><td>$default_display"),
					'</td></tr>',
				);
			} sort keys %methods
		),
		'</table>',
	);
}


sub idisp_tlb_data {
	return join( '',
		h2(
			qq{<a name="idisp_tlb_data">Dump of Parsed Type Lib Info:</a>}
		),
		pre(escapeHTML(Dumper( $interfaces, $uuid ))),
	);
}




sub get_property_hashes {
	# given an adsi object, return a hash of property hashes
	# only arg is an adsi object
	my $p_interface = &get_primary_interface( $_[0] );
	my %properties;
	my %property_interfaces;
	for my $i (  @{ $interfaces->{$p_interface}{'isa'} }  ) {
		@properties{  keys %{ $interfaces->{$i}{'properties'} }  } = ();
		@property_interfaces{   keys %{ $interfaces->{$i}{'properties'} }  }
			= (    values %{ $interfaces->{$i}{'properties'} }  );
	}	
	if ( $groups_members_as_properties ) {
		$properties{'Groups'}++  if $_[0]->{'Class'} eq 'User';
		$properties{'Members'}++ if $_[0]->{'Class'} eq 'Group';
	}
	my $properties = {
		map {  $_ => { 'reqd'  => 'Unknown' }  }
		keys %properties
	};
	my $class_schema;
	if (  $class_schema = &get_class_schema( $_[0] )  ) {
		for my $p_type (qw{ Optional Mandatory }) {
			if (  defined $class_schema->{$p_type.'Properties'}  ) {
				for my $p_name (  @{ $class_schema->{$p_type.'Properties'} }  ) {
					next unless defined $p_name and length $p_name;
						# don't know why, but MS has some empties in these lists!
					$properties->{$p_name}{'reqd'} = $p_type;
				}
			}
		}
	}
	my $schema = &get_schema( $_[0] );
	for my $p_name ( keys %$properties ) {
		# start with the property name
		$properties->{$p_name}{'property'} = $p_name;
			# we'll create a link to get info later if possible
		# now try to find out the type for the property (and syntax for that type)
		if ($schema) { # need a $schema to do that properly
			# look in the normal place first:
			my $try_path = $schema->{'AdsPath'}.'/'.$p_name.',Property';
			my $try;
			if (  $try = &get_adsi_object_from_path( $try_path )  ) {
				# great... turn the property into a path to more info on the property:
				# that path will later be changed into a link
				$properties->{$p_name}{'property'} = $try_path;
				$try_path =  $schema->{'AdsPath'}.'/'.$try->{'Syntax'}.',Syntax';
				$try = &get_adsi_object_from_path( $try_path );
				# cool... now we can have a path for syntax info too:
				$properties->{$p_name}{'syntax'} = $try_path if $try;
			} else {
				# not in the normal place, so guess:
				my %syntax_guesses = (
					(  map {($_ => 'ADsPath')} qw{ADsPath Parent Schema}  ),
					(  map {($_ => 'String') } qw{Class Name}  ),
				);
				$try_path = $schema->{'AdsPath'}.'/'.$syntax_guesses{$p_name}.',Syntax';
				$try = &get_adsi_object_from_path( $try_path );
				$properties->{$p_name}{'syntax'} = $try_path if $try;
				$properties->{$p_name}{'syntax_guessed'} = 1 if $syntax_guesses{$p_name};
			}
			my $syntax = &get_adsi_object_from_path( $properties->{$p_name}{'syntax'} );
			if ( $syntax ) {
				$properties->{$p_name}{'type'}
					= $syntax->{'Name'} || 'unknown ('.__LINE__.')';
			} else {
				$properties->{$p_name}{'type'} = 'undef ('.__LINE__.')';
			}
		}
		# GetInfoEx ensures property value will be in cache to fetch when we want:
		$_[0]->GetInfoEx( [$p_name], 0 );
		$properties->{$p_name}{'value'} = $_[0]->{$p_name};
		unless ( $properties->{$p_name}{'value'} ) {
			# if we didn't get a value the easy way, try explicit Get call:
			my $try = $_[0]->Get($p_name);
			# use intermediate $try to avoid overwriting an earlier 0 with undef
			if ( ($properties->{$p_name}{'reqd'} ne 'Unknown') and (
					( defined $try and !defined $properties->{$p_name}{'value'} )
					or
					( $try and !$properties->{$p_name}{'value'} )
				)
			) {
				$properties->{$p_name}{'value'} = $try;
			}
		}
		# stash a copy for safe keeping... the above gets processed for display
		$properties->{$p_name}{'_safe_value_'} = $properties->{$p_name}{'value'};
		# notes will hold a geeky representation for my use in testing stuff:
		$properties->{$p_name}{'notes'} = pre( escapeHTML(
			&Dumper( $properties->{$p_name}{'value'} ),
		));
		# need to figure out how to display some of the more opaque property values
		# also need to extract more of this display code into subs, like
		# pretty_value_interval
		# But for now, the bulk of that sort of code is as follows:
		if (  ref $properties->{$p_name}{'value'}  ) {
			if (  ref $properties->{$p_name}{'value'} eq 'Win32::OLE'  ) {
				$properties->{$p_name}{'value'}
					= &pretty_value_contained_objects( $properties->{$p_name}{'value'} );
			} elsif (  ref $properties->{$p_name}{'value'} eq 'ARRAY'  ) {
				my %type_guess = (
					'Containment'         => 'Class',
					'PossibleSuperiors'   => 'Class',
					'MandatoryProperties' => 'Property',
					'OptionalProperties'  => 'Property',
				);
				$properties->{$p_name}{'value'} = join( qq{<br>\n}, (
					$schema && scalar(  grep {$_ eq $p_name} (keys %type_guess)  )
					? (
						map {
							my $try_path
								= $schema->{'AdsPath'}.'/'.$_.','.$type_guess{$p_name};
							&get_adsi_object_from_path( $try_path )
								? &get_property_or_syntax_link( $try_path )
								: $_
							;
						} @{ $properties->{$p_name}{'value'} }
					)
					: (
						map { escapeHTML($_) }
						@{ $properties->{$p_name}{'value'} }
					)
				),);
			} elsif (
				ref $properties->{$p_name}{'value'} eq 'Win32::OLE::Variant'
				and $properties->{$p_name}{'type'}  eq 'Time'
			) {
				$properties->{$p_name}{'value'} = escapeHTML(
					$properties->{$p_name}{'value'}
					# .'('.${  $properties->{$p_name}{'value'}  }.')' # shows ticks
				);
			} else {
				# ref of type we don't know how to handle yet!
				$properties->{$p_name}{'value'}
					= escapeHTML(  $properties->{$p_name}{'value'}  );
			}
		} elsif ( $properties->{$p_name}{'type'} eq 'ADsPath' ) {
			$properties->{$p_name}{'value'}
				= &all_partial_links_for_path(  $properties->{$p_name}{'value'}  )
		} elsif (
			$_[0]->{'Class'} eq 'FileShare' and (
				$p_name eq 'Path'
				or
				$p_name eq 'Name'
			) and ( $properties->{$p_name}{'value'} !~ /a href/ )
		) {
			my($server) = ( $_[0]->{'Parent'} =~ m{^[^:]+://[^/]+/([^/]+)/} );
			$properties->{$p_name}{'value'} = join( '',
				'<a href="file://',
				escapeHTML( '//' . $server . '/' . $_[0]->{'Name'} ),
				'">',
				escapeHTML( $properties->{$p_name}{'value'} ),
				'</a>',
			);
			my $href = $properties->{$p_name}{'value'};
		} elsif (
			$properties->{$p_name}{'value'} =~ m{^\\\\[^\\]+}
			and $properties->{$p_name}{'type'} eq 'Path'
		) {
			my $href = $properties->{$p_name}{'value'};
			$href =~ s{\\}{/}g;
			$properties->{$p_name}{'value'} = join( '',
				'<a href="file://',
				escapeHTML( $href ),
				'">',
				escapeHTML( $properties->{$p_name}{'value'} ),
				'</a>',
			);
		} elsif ( $p_name eq 'Class' and $properties->{$p_name}{'value'} ) {
			$properties->{$p_name}{'value'} = &get_class_link( $_[0] )
		} elsif (
			$properties->{$p_name}{'value'}
			and
			$properties->{$p_name}{'value'} > 0
			and (
				$properties->{$p_name}{'type'} eq 'Time'
				or
				$properties->{$p_name}{'type'} eq 'Interval'
			)
		) {
			$properties->{$p_name}{'value'} = &pretty_value_interval(
				$properties->{$p_name}{'value'}
			);
		} elsif ( $schema and $p_name eq 'Syntax' and $_[0]->{'Class'} eq 'Property' ) {
			my $try_path
				= $schema->{'AdsPath'}.'/'.$properties->{$p_name}{'value'}.',Syntax';
			$properties->{$p_name}{'value'} = &get_property_or_syntax_link(
				&get_adsi_object_from_path( $try_path )
					? $try_path
					: $properties->{$p_name}{'value'}
			);
		} else {
			escapeHTML(  $properties->{$p_name}{'value'}  );
		}
		# if an unknown property looks like an IADs property, say so:
		if (  $properties->{$p_name}{'reqd'} eq 'Unknown'  ) {
			# try to guess if we think we can
			# for now, the following seems to work ok...
			if (  grep {$_ eq $p_name} keys %{ $interfaces->{'IADs'}{'properties'} }  ) {
				$properties->{$p_name}{'reqd'} = 'IADs';
			}
		}
		unless (
			defined $properties->{$p_name}{'value'}
			and length $properties->{$p_name}{'value'}
		) {
			# put *something* in there (NN 4.x won't color empty table cells)
			$properties->{$p_name}{'value'} = ' &#160; ';
		}
		# link up property name to syntax, and type to type def:
		$properties->{$p_name}{'property'}
			= &get_property_or_syntax_link( $properties->{$p_name}{'property'} );
		$properties->{$p_name}{'syntax'} = ( $properties->{$p_name}{'syntax'}
			? join( '',
				( $properties->{$p_name}{'syntax_guessed'} ? '(' : '' ),
				'<a href="',
				&info_link_for_path( $properties->{$p_name}{'syntax'} ),
				'">',
				$properties->{$p_name}{'type'},
				'</a>',
				( $properties->{$p_name}{'syntax_guessed'} ? ')' : '' ),
			)
			: '?'
		);
		if ( exists ${ $property_interfaces{$p_name} }{'set'} ) {
			$properties->{$p_name}{'property'}
				= strong( $properties->{$p_name}{'property'} );
		}
	} # repeat for each property
	return $properties;
}

sub pretty_value_contained_objects {
	# return a view of what stuff might be inside an adsi object
	# only arg is an adsi object
	my $quiet = (caller(1))[3] ne 'main::idisp_contained_objects';
	# quite output (no h2 and hr tags) for anyone but the above
	my $enum;
	eval {$enum = Win32::OLE::Enum->new($_[0])};
	my %contents;
	if ( $enum ) {
		for my $nested_object ( Win32::OLE::in $_[0] ) {
			my $name  = $nested_object->{'Name'};
			my $class = $nested_object->{'Class'};
			# in the href's below, we could call $nested_object->{'AdsPath'}
			# to get the path, but that's much slower than manual construction
			push(   @{  $contents{ lc($class) }  },
				'<a href="'
				. &info_link_for_path( $nested_object->{'AdsPath'}.','.$class )
				. '">'
				. escapeHTML( $name )
				.'</a>'
			);
			# adsi won't show lanmanserver's most usefull identity
			# through enumeration of its container, so 'out' it manually:
			if (  lc($name)  eq 'lanmanserver'  and  lc($class) eq 'service'  ) {
				push(   @{  $contents{ lc('File'.$class) }  },
					'<a href="'
					. &info_link_for_path( $nested_object->{'AdsPath'}.','.'File'.$class )
					. '">'
					. escapeHTML( $name )
					.'</a>'
				);
			}
		}
	}
	unless ( keys %contents ) {
		# don't waste time building a table
		return(  $quiet ? '' : h2(
			'<a name="idisp_contained_objects">Leaf Node: Contains Zero Objects</a>',
		));
	}
	my $total;
	my $return = '<table border="0" cellpadding="5"><tr align="center" valign="bottom">';
	my @item_order = sort keys %contents;
	for ( @item_order ) {
		$total += @{ $contents{$_} };
		my $s = (  @{ $contents{$_} } == 1   ? '' : 's'  );
		if ( $quiet ) {
			my $head = join( ' ',
				scalar(  @{ $contents{$_} }  ),
				ucfirst($_),
				"Object$s",
			);
			$return .= join( '',
				'<td rowspan="2">&#160;</td><td><code>',
				$head,
				'</code><br><code>',
				( '=' x length($head) ),
				'</code><br></td>',
			);
		} else {
			$return .= join( '',
				'<th>',
				scalar(  @{ $contents{$_} }  ),
				' ',
				escapeHTML( ucfirst($_) ),
				" Object$s",
				'<hr noshade></th>',
			);
		}
	}
	$return .= '</tr><tr align="left" valign="top">';
	for my $class ( @item_order ) {
		$return .= join( '',
			'<td>',
			small(
				join( "<br>\n",
					map  {  $_->[0]  }
					sort {  $a->[1] cmp $b->[1]  }
					map  {  [ $_, lc($_) ]  }
					@{ $contents{$class} }
				)
			),
			'</td>',
		);
	}
	$return .= '</tr></table>';
	my $s = $total == 1  ? '' : 's';
	$total = $quiet
		? (  @item_order == 1 ? '' : qq{$total object$s:}  )
		: h2(
			qq{<a name="idisp_contained_objects">This Node Contains $total Object$s:</a>}
		)
	;
	return $total . $return;
}

sub pretty_value_interval {
	my $secs  = Time::Seconds->new( $_[0] );
	my $days  = int( $secs->days );
	$secs -= $days * ONE_DAY;
	my $hours = int( $secs->hours );
	$secs -= $hours * ONE_HOUR;
	my $mins  = int( $secs->minutes );
	$secs -= $mins * ONE_MINUTE;
	return join( '',
		( $days
			? $days . ' day' . ($days == 1 ? '' : 's')
				. (  ($hours or $mins or $secs) ? ', ' : ''  )
			: ''
		),
		( $hours
			? $hours . ' hour' . ($hours == 1 ? '' : 's')
				. (  ($mins or $secs) ? ', ' : ''  )
			: ''
		),
		( $mins
			? $mins . ' minute' . ($mins == 1 ? '' : 's')
				. (  ($secs) ? ', ' : ''  )
			: ''
		),
		( $secs ? $secs . ' second' . ($secs == 1 ? '' : 's') : '' ),
	); # . '('.$properties->{$p_name}{'value'}.')' # shows ticks
}




sub approve_methods_as_psuedoproperties {
	# only approve those methods that return data from zero args and
	# have zero side effects (no object creation/deletion/modification)
	##
	# so far as I can tell, the only interesting things here are
	# Members (of groups) and Groups (of users). Nothing else seems
	# to be of much value... hence the $groups_members_as_properties
	# hack near the top of the script to just not bother with these
	# any more, and treat the two interesting exceptions as properties.
	##
	$_->{'psuedoproperty'} = 1 for (
	#	$interfaces->{'ITypeLib'                 }{'methods'}{'GetTypeComp'}, # _stdcall
	#	$interfaces->{'ITypeLib'                 }{'methods'}{'RemoteGetTypeInfoCount'}, # _stdcall
	#	$interfaces->{'ITypeLib'                 }{'methods'}{'RemoteGetLibAttr'}, # _stdcall
	#	$interfaces->{'IDirectoryObject'         }{'methods'}{'GetObjectInformation'}, # _stdcall
		$interfaces->{'IADsGroup'                }{'methods'}{'Members'},
		$interfaces->{'IADsProperty'             }{'methods'}{'Qualifiers'},
		$interfaces->{'IADsUser'                 }{'methods'}{'Groups'},
		$interfaces->{'IADsPathname'             }{'methods'}{'GetNumElements'},
		$interfaces->{'IADsComputerOperations'   }{'methods'}{'Status'},
		$interfaces->{'IADsPrintQueueOperations' }{'methods'}{'PrintJobs'},
		$interfaces->{'IADsClass'                }{'methods'}{'Qualifiers'},
		$interfaces->{'IADsFileServiceOperations'}{'methods'}{'Resources'},
		$interfaces->{'IADsFileServiceOperations'}{'methods'}{'Sessions'},
	#	$interfaces->{'IPrivateDispatch'         }{'methods'}{'ADSIGetTypeInfoCount'}, # _stdcall
	#	$interfaces->{'IDispatch'                }{'methods'}{'GetTypeInfoCount'}, # _stdcall
		$interfaces->{'ITypeInfo'                }{'methods'}{'GetContainingTypeLib'}, # _stdcall
	#	$interfaces->{'ITypeInfo'                }{'methods'}{'GetTypeComp'}, # _stdcall
	#	$interfaces->{'ITypeInfo'                }{'methods'}{'RemoteGetTypeAttr'}, # _stdcall
	);
}


sub set_tlb_info {
	# I thought about yanking this code out and leaving
	# just the hash returned by parsed_tlb_info(), but
	# if anyone else wants to parse tlb files, I thought
	# this might be a useful starting point.
	my @pre_parsed = &parsed_tlb_info();
	if ( @pre_parsed ) {
		($interfaces, $uuid) = @pre_parsed;
		return;
		# that's the normal way things work. However, 
		# when I was still actively working on the parse code
		# I would delete the data in parsed_tlb_info() and
		# re-parse (those results were dumped, and then I
		# pasted them into parsed_tlb_info()... the dump code
		# is no longer present).
	} # else...
	my $tlb;  { local $/;  $tlb = <main::DATA>; }
	my(%interfaces, %uuid);
	@interfaces{ $tlb =~ m{\binterface\s+(\w+)\s*;}g } = ();
		# finds the pre-declared interfaces
	for my $i (keys %interfaces) {
		next unless $tlb =~ m{
			\n\n
			([\s\t]*)                   # $1 is indent level (easiest way to match braces)
			(?:\[
				([^\]]+)                # $2 odl/oleautomation/dual/etc
			\])\n
			\1
			interface \s+ $i
			\s* : \s* (\w+) \s*         # $3 is the interface $i will be extending
			\{(                         # $4 captures stuff inside our opening brace
				.+?                     # (non-greedy +? allows the following to work)
			)\n                         # our closing brace is determined to be the
			\1\};                       # first closing brace at same indent level as opening
			(?:
				\n\n
				\1\[
					[^\]]+              # don't yet care about details
				\]\n
				\1 coclass \s+ (\w+)    # $5 coclass name
				\s* \{                  # don't yet care about details
					.*?interface\s+ $i
					.*?
				\1\};
			)?
		}sx;
		my($i_attr, $extends, $details, $coclass_name) = ($2, $3, $4, $5);
		$interfaces{$i}{'extends'} = $extends;
		$interfaces{$i}{'coclass'} = $coclass_name if $coclass_name;
			# could one day parse out coclass details and put them
			# all in here instead of just the name
			# ... but I don't yet know what I'd do with that info
		$i_attr = &parse_attributes( $i_attr );
		@{ $interfaces{$i}{'attributes'} }{keys %$i_attr} = (values %$i_attr)
			if keys %$i_attr;
		# mp is short for "method or property"
		my @mp_declare = split( ';', $details);
		for ( @mp_declare ) {
			next unless m{^\s*
				(?:\[
					([^\]]+)                 # $1 propget/propput/restricted/id/etc
				\])?
				\s*
				HRESULT \s+
				(?: (\w+\s) \s*)?            # $2 _stdcall
				(\w+) \s*                    # $3 method/property name
				\(\s*
					([^)]*)                  # $4 args/returns
				\)
			}x;
			my($mp_attr, $call_conv, $mp_name, $in_out) = ($1, $2, $3, $4);
			$mp_attr = &parse_attributes( $mp_attr );
			my($mp_name_context, $io_context); # where to stash our data
			if ( exists ${$mp_attr}{'propget'} ) {
				$mp_name_context = $interfaces{$i}{'properties'}{$mp_name};
				$io_context      = $interfaces{$i}{'properties'}{$mp_name}{'get'};
			} elsif ( exists ${$mp_attr}{'propput'} ) {
				$mp_name_context = $interfaces{$i}{'properties'}{$mp_name};
				$io_context      = $interfaces{$i}{'properties'}{$mp_name}{'set'};
			} else {
				$io_context = $mp_name_context = $interfaces{$i}{'methods'}{$mp_name};
			}
			delete ${$mp_attr}{$_} for qw{propget propput}; # recorded by other means
			@{ $mp_name_context->{'attributes'} }{keys %$mp_attr} = (values %$mp_attr)
				if keys %$mp_attr;
			$in_out = [  split(/,[\s\t]*\n\s+/, $in_out)  ];
			$mp_name_context->{'calling_convention'} = $call_conv if $call_conv;
			for ( @$in_out ) {
				next unless my($io, $decl) = m{ \[ (.+?) \]  \s* (.*?) \s* $}x;
				if ( $io =~ m/in/ ) {
					push(  @{ $io_context->{'args'} },  $decl,  );
				}
				if ( $io =~ m/out/ ) {
					push(  @{ $io_context->{'returns'} },  $decl,  );
				}
			}
		}
	}
	# now determine the @ISA equivialnt for each interface...
	for my $i ( keys %interfaces ) {
		my $isa = $i;
		my $try = $interfaces{$i}{'extends'};
		while ( $try ) {
			push(  @{ $interfaces{$i}{'isa'} },  $isa  );
			$isa = $try;
			$try = $interfaces{$isa}{'extends'};
		}
		push(  @{ $interfaces{$i}{'isa'} },  $isa  );
	}
	# ...and a nice order for attractive printing, and uuid info
	$interfaces = \%interfaces;
	for my $i (
		sort {
			@{ $interfaces{$a}{'isa'} }  <=>  @{ $interfaces{$b}{'isa'} }
			or $a cmp $b
		} keys %interfaces
	) {
		&determine_dependence($i) unless $interfaces{$i}{'pretty_print_order'};
		if (
			exists $interfaces{$i}{'attributes'}
			and
			exists $interfaces{$i}{'attributes'}{'uuid'}
			and
			defined $interfaces{$i}{'attributes'}{'uuid'}
			and
			length $interfaces{$i}{'attributes'}{'uuid'}
		) {
			$uuid{ $interfaces{$i}{'attributes'}{'uuid'} } = $i;
		}
	}
	$uuid = \%uuid;
	return;
}

sub parse_attributes {
	# only arg is contents of attr list by scalarref in $_[0]
	return({
		map {
			s{^\s+}{}; s{\s+$}{}; # strip excess whitespace
			m{([^\(\n]+)(?:\(([^\)\n]+)\))?\n?};
			$2 ? ($1 => $2) : ($_ => undef);
		} split(/\s*,\s*/, shift)
	});
}

BEGIN {
	# ensure that @prime and $index are known when &determine_dependence is called
	# primes from http://www.utm.edu/research/primes/lists/small/10000.txt
	# need at least as many keys as interfaces (about 70 as I type this)
	##
	# there's probably a better way, but this was the first to come to mind
	my @prime = qw(
		  2    3    5    7   11   13   17   19   23   29
		 31   37   41   43   47   53   59   61   67   71
		 73   79   83   89   97  101  103  107  109  113
		127  131  137  139  149  151  157  163  167  173
		179  181  191  193  197  199  211  223  227  229
		233  239  241  251  257  263  269  271  277  281
		283  293  307  311  313  317  331  337  347  349
		353  359  367  373  379  383  389  397  401  409
		419  421  431  433  439  443  449  457  461  463
		467  479  487  491  499  503  509  521  523  541
	);
	my $index = 0;
	sub determine_dependence {
		# for rough sort by how much one interface depends on others
		# Result ensures that each interface has a higher dependancy
		# value than does any interface from which it inherets.
		use Math::Bigint;
		my $i = shift;
		return $interfaces->{$i}{'pretty_print_order'} if $interfaces->{$i}{'pretty_print_order'};
		if (  @{ $interfaces->{$i}{'isa'} }  ==  1  ) {
			return( $interfaces->{$i}{'pretty_print_order'} =
				Math::BigInt->new( $prime[$index++] )
				# hmmm... prime index ++ ...sounds like credit card interest rates
			);
		} else {
			$interfaces->{$i}{'pretty_print_order'} = $prime[$index++];
			for my $isa (   @{ $interfaces->{$i}{'isa'} }[  1 .. $#{ $interfaces->{$i}{'isa'} }  ]   ) {
				$interfaces->{$i}{'pretty_print_order'} *= &determine_dependence( $isa );
			}
			return $interfaces->{$i}{'pretty_print_order'};
		}
	}
}


sub parsed_tlb_info {
	# return; # uncomment to parse from scratch out of main::DATA
	return(
		{
			'IADsTimestamp' => {
				'coclass' => 'Timestamp',
				'pretty_print_order' => bless( do{\(my $o = '+14972')}, 'Math::BigInt' ),
				'isa' => [
					'IADsTimestamp',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B2F5A901-4080-11D1-A3AC-00C04FB950DC'
				},
				'properties' => {
					'EventID' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'WholeSeconds' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsNameTranslate' => {
				'coclass' => 'NameTranslate',
				'pretty_print_order' => bless( do{\(my $o = '+9652')}, 'Math::BigInt' ),
				'isa' => [
					'IADsNameTranslate',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B1B272A3-3625-11D1-A3A4-00C04FB950DC'
				},
				'methods' => {
					'SetEx' => {
						'args' => [
							'long lnFormatType',
							'VARIANT pVar'
						],
						'attributes' => {
							'id' => '0x00000006'
						}
					},
					'Set' => {
						'args' => [
							'long lnSetType',
							'BSTR bstrADsPath'
						],
						'attributes' => {
							'id' => '0x00000004'
						}
					},
					'InitEx' => {
						'args' => [
							'long lnSetType',
							'BSTR bstrADsPath',
							'BSTR bstrUserID',
							'BSTR bstrDomain',
							'BSTR bstrPassword'
						],
						'attributes' => {
							'id' => '0x00000003'
						}
					},
					'Init' => {
						'args' => [
							'long lnSetType',
							'BSTR bstrADsPath'
						],
						'attributes' => {
							'id' => '0x00000002'
						}
					},
					'GetEx' => {
						'args' => [
							'long lnFormatType'
						],
						'returns' => [
							'VARIANT* pVar'
						],
						'attributes' => {
							'id' => '0x00000007'
						}
					},
					'Get' => {
						'args' => [
							'long lnFormatType'
						],
						'returns' => [
							'BSTR* pbstrADsPath'
						],
						'attributes' => {
							'id' => '0x00000005'
						}
					}
				},
				'properties' => {
					'ChaseReferral' => {
						'set' => {
							'args' => [
								'long rhs'
							]
						},
						'attributes' => {
							'id' => '0x00000001'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IEnumVARIANT' => {
				'pretty_print_order' => bless( do{\(my $o = '+46')}, 'Math::BigInt' ),
				'isa' => [
					'IEnumVARIANT',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'hidden' => undef,
					'uuid' => '00020404-0000-0000-C000-000000000046'
				},
				'methods' => {
					'Skip' => {
						'args' => [
							'unsigned long celt'
						],
						'calling_convention' => '_stdcall '
					},
					'Clone' => {
						'returns' => [
							'IEnumVARIANT** ppenum'
						],
						'calling_convention' => '_stdcall '
					},
					'Reset' => {
						'calling_convention' => '_stdcall '
					},
					'Next' => {
						'args' => [
							'unsigned long celt',
							'VARIANT* rgvar'
						],
						'returns' => [
							'unsigned long* pceltFetched'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsAggregator' => {
				'pretty_print_order' => bless( do{\(my $o = '+10')}, 'Math::BigInt' ),
				'isa' => [
					'IADsAggregator',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '52DB5FB0-941F-11D0-8529-00C04FD8D503'
				},
				'methods' => {
					'DisconnectAsAggregator' => {
						'calling_convention' => '_stdcall '
					},
					'ConnectAsAggregator' => {
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsOU' => {
				'pretty_print_order' => bless( do{\(my $o = '+89626192')}, 'Math::BigInt' ),
				'isa' => [
					'IADsOU',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'A2F733B8-EFFE-11CF-8ABC-00C04FD8D503'
				},
				'properties' => {
					'LocalityName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PostalAddress' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'BusinessCategory' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'FaxNumber' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'SeeAlso' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'TelephoneNumber' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsSecurityDescriptor' => {
				'coclass' => 'SecurityDescriptor',
				'pretty_print_order' => bless( do{\(my $o = '+14668')}, 'Math::BigInt' ),
				'isa' => [
					'IADsSecurityDescriptor',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B8C787CA-9BDD-11D0-852C-00C04FD8D503'
				},
				'methods' => {
					'CopySecurityDescriptor' => {
						'returns' => [
							'IDispatch** ppSecurityDescriptor'
						],
						'attributes' => {
							'id' => '0x0000000c'
						}
					}
				},
				'properties' => {
					'DaclDefaulted' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000009'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'Revision' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'GroupDefaulted' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000007'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'Group' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000006'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'SaclDefaulted' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000b'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'DiscretionaryAcl' => {
						'set' => {
							'args' => [
								'IDispatch* retval'
							]
						},
						'attributes' => {
							'id' => '0x00000008'
						},
						'get' => {
							'returns' => [
								'IDispatch** retval'
							]
						}
					},
					'OwnerDefaulted' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000005'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'Control' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Owner' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'SystemAcl' => {
						'set' => {
							'args' => [
								'IDispatch* retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000a'
						},
						'get' => {
							'returns' => [
								'IDispatch** retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsReplicaPointer' => {
				'coclass' => 'ReplicaPointer',
				'pretty_print_order' => bless( do{\(my $o = '+14516')}, 'Math::BigInt' ),
				'isa' => [
					'IADsReplicaPointer',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'F60FB803-4080-11D1-A3AC-00C04FB950DC'
				},
				'properties' => {
					'ReplicaType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Count' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000005'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'ReplicaNumber' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'ReplicaAddressHints' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000006'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'ServerName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADs' => {
				'pretty_print_order' => bless( do{\(my $o = '+4484')}, 'Math::BigInt' ),
				'isa' => [
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'FD8256D0-FD15-11CE-ABC4-02608C9E7553'
				},
				'methods' => {
					'GetInfoEx' => {
						'args' => [
							'VARIANT vProperties',
							'long lnReserved'
						],
						'attributes' => {
							'id' => '0x0000000e'
						}
					},
					'PutEx' => {
						'args' => [
							'long lnControlCode',
							'BSTR bstrName',
							'VARIANT vProp'
						],
						'attributes' => {
							'id' => '0x0000000d'
						}
					},
					'GetInfo' => {
						'attributes' => {
							'id' => '0x00000008'
						}
					},
					'GetEx' => {
						'args' => [
							'BSTR bstrName'
						],
						'returns' => [
							'VARIANT* pvProp'
						],
						'attributes' => {
							'id' => '0x0000000c'
						}
					},
					'Get' => {
						'args' => [
							'BSTR bstrName'
						],
						'returns' => [
							'VARIANT* pvProp'
						],
						'attributes' => {
							'id' => '0x0000000a'
						}
					},
					'SetInfo' => {
						'attributes' => {
							'id' => '0x00000009'
						}
					},
					'Put' => {
						'args' => [
							'BSTR bstrName',
							'VARIANT vProp'
						],
						'attributes' => {
							'id' => '0x0000000b'
						}
					}
				},
				'properties' => {
					'GUID' => {
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Class' => {
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Schema' => {
						'attributes' => {
							'id' => '0x00000007'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'ADsPath' => {
						'attributes' => {
							'id' => '0x00000005'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Name' => {
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Parent' => {
						'attributes' => {
							'id' => '0x00000006'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsAccessControlList' => {
				'coclass' => 'AccessControlList',
				'pretty_print_order' => bless( do{\(my $o = '+5092')}, 'Math::BigInt' ),
				'isa' => [
					'IADsAccessControlList',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B7EE91CC-9BDD-11D0-852C-00C04FD8D503'
				},
				'methods' => {
					'AddAce' => {
						'args' => [
							'IDispatch* pAccessControlEntry'
						],
						'attributes' => {
							'id' => '0x00000005'
						}
					},
					'CopyAccessList' => {
						'returns' => [
							'IDispatch** ppAccessControlList'
						],
						'attributes' => {
							'id' => '0x00000007'
						}
					},
					'RemoveAce' => {
						'args' => [
							'IDispatch* pAccessControlEntry'
						],
						'attributes' => {
							'id' => '0x00000006'
						}
					}
				},
				'properties' => {
					'_NewEnum' => {
						'attributes' => {
							'id' => '0xfffffffc',
							'restricted' => undef
						},
						'get' => {
							'returns' => [
								'IUnknown** retval'
							]
						}
					},
					'AceCount' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'AclRevision' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsNetAddress' => {
				'coclass' => 'NetAddress',
				'pretty_print_order' => bless( do{\(my $o = '+9956')}, 'Math::BigInt' ),
				'isa' => [
					'IADsNetAddress',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B21A50A9-4080-11D1-A3AC-00C04FB950DC'
				},
				'properties' => {
					'Address' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'AddressType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsCaseIgnoreList' => {
				'coclass' => 'CaseIgnoreList',
				'pretty_print_order' => bless( do{\(my $o = '+6004')}, 'Math::BigInt' ),
				'isa' => [
					'IADsCaseIgnoreList',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '7B66B533-4680-11D1-A3B4-00C04FB950DC'
				},
				'properties' => {
					'CaseIgnoreList' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsResource' => {
				'pretty_print_order' => bless( do{\(my $o = '+99849712')}, 'Math::BigInt' ),
				'isa' => [
					'IADsResource',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '34A05B20-4AAB-11CF-AE2C-00AA006EBFB9'
				},
				'properties' => {
					'LockCount' => {
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'UserPath' => {
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'User' => {
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Path' => {
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsCollection' => {
				'pretty_print_order' => bless( do{\(my $o = '+6308')}, 'Math::BigInt' ),
				'isa' => [
					'IADsCollection',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '72B945E0-253B-11CF-A988-00AA006BC149'
				},
				'methods' => {
					'Remove' => {
						'args' => [
							'BSTR bstrItemToBeRemoved'
						],
						'attributes' => {
							'id' => '0x00000005'
						}
					},
					'GetObject' => {
						'args' => [
							'BSTR bstrName'
						],
						'returns' => [
							'VARIANT* pvItem'
						],
						'attributes' => {
							'id' => '0x00000006'
						}
					},
					'Add' => {
						'args' => [
							'BSTR bstrName',
							'VARIANT vItem'
						],
						'attributes' => {
							'id' => '0x00000004'
						}
					}
				},
				'properties' => {
					'_NewEnum' => {
						'attributes' => {
							'id' => '0xfffffffc'
						},
						'get' => {
							'returns' => [
								'IUnknown** ppEnumerator'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsPrintJob' => {
				'pretty_print_order' => bless( do{\(my $o = '+91670896')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPrintJob',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '32FB6780-1ED0-11CF-A988-00AA006BC149'
				},
				'properties' => {
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'UntilTime' => {
						'set' => {
							'args' => [
								'DATE retval'
							]
						},
						'attributes' => {
							'id' => '0x00000017'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'TimeSubmitted' => {
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'UserPath' => {
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Notify' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000018'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'TotalPages' => {
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'User' => {
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'NotifyPath' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000019'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'StartTime' => {
						'set' => {
							'args' => [
								'DATE retval'
							]
						},
						'attributes' => {
							'id' => '0x00000016'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'HostPrintQueue' => {
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Size' => {
						'attributes' => {
							'id' => '0x000000ea'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Priority' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsComputer' => {
				'pretty_print_order' => bless( do{\(my $o = '+75994832')}, 'Math::BigInt' ),
				'isa' => [
					'IADsComputer',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'EFE3CC70-1D9F-11CF-B1F3-02608C9E7553'
				},
				'properties' => {
					'Location' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Site' => {
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'ProcessorCount' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001e'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Processor' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001d'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'NetAddresses' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'MemorySize' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'StorageCapacity' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000020'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PrimaryUser' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'OperatingSystemVersion' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001b'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'ComputerID' => {
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Owner' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000016'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Division' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000017'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Model' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001c'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'OperatingSystem' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001a'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Role' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000019'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Department' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000018'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsBackLink' => {
				'coclass' => 'BackLink',
				'pretty_print_order' => bless( do{\(my $o = '+5548')}, 'Math::BigInt' ),
				'isa' => [
					'IADsBackLink',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'FD1302BD-4080-11D1-A3AC-00C04FB950DC'
				},
				'properties' => {
					'RemoteID' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'ObjectName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'ITypeLib' => {
				'pretty_print_order' => bless( do{\(my $o = '+106')}, 'Math::BigInt' ),
				'isa' => [
					'ITypeLib',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '00020402-0000-0000-C000-000000000046'
				},
				'methods' => {
					'GetTypeComp' => {
						'returns' => [
							'ITypeComp** ppTComp'
						],
						'calling_convention' => '_stdcall '
					},
					'LocalReleaseTLibAttr' => {
						'calling_convention' => '_stdcall '
					},
					'GetTypeInfoOfGuid' => {
						'args' => [
							'GUID* GUID'
						],
						'returns' => [
							'ITypeInfo** ppTInfo'
						],
						'calling_convention' => '_stdcall '
					},
					'GetTypeInfo' => {
						'args' => [
							'unsigned int index'
						],
						'returns' => [
							'ITypeInfo** ppTInfo'
						],
						'calling_convention' => '_stdcall '
					},
					'GetTypeInfoType' => {
						'args' => [
							'unsigned int index'
						],
						'returns' => [
							'tagTYPEKIND* pTKind'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteGetDocumentation' => {
						'args' => [
							'int index',
							'unsigned long refPtrFlags'
						],
						'returns' => [
							'BSTR* pBstrName',
							'BSTR* pBstrDocString',
							'unsigned long* pdwHelpContext',
							'BSTR* pBstrHelpFile'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteGetTypeInfoCount' => {
						'returns' => [
							'unsigned int* pctinfo'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteGetLibAttr' => {
						'returns' => [
							'tagTLIBATTR** ppTLibAttr',
							'DWORD* pDummy'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteFindName' => {
						'args' => [
							'LPWSTR szNameBuf',
							'unsigned long lHashVal',
							'unsigned short* pcFound'
						],
						'returns' => [
							'ITypeInfo** ppTInfo',
							'long* rgMemId',
							'unsigned short* pcFound',
							'BSTR* pBstrLibName'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteIsName' => {
						'args' => [
							'LPWSTR szNameBuf',
							'unsigned long lHashVal'
						],
						'returns' => [
							'long* pfName',
							'BSTR* pBstrLibName'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsPrintQueue' => {
				'pretty_print_order' => bless( do{\(my $o = '+94397168')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPrintQueue',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B15160D0-1226-11CF-A985-00AA006BC149'
				},
				'properties' => {
					'Location' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'DefaultJobPriority' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000017'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'UntilTime' => {
						'set' => {
							'args' => [
								'DATE retval'
							]
						},
						'attributes' => {
							'id' => '0x00000016'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'PrintDevices' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001a'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'StartTime' => {
						'set' => {
							'args' => [
								'DATE retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'NetAddresses' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001b'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'BannerPage' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000019'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Datatype' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Priority' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000018'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Model' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PrinterPath' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PrintProcessor' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsSyntax' => {
				'pretty_print_order' => bless( do{\(my $o = '+108028528')}, 'Math::BigInt' ),
				'isa' => [
					'IADsSyntax',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'C8F93DD2-4AE0-11CF-9E73-00AA004A5691'
				},
				'properties' => {
					'OleAutoDataType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsAggregatee' => {
				'pretty_print_order' => bless( do{\(my $o = '+6')}, 'Math::BigInt' ),
				'isa' => [
					'IADsAggregatee',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '1346CE8C-9039-11D0-8528-00C04FD8D503'
				},
				'methods' => {
					'DisconnectAsAggregatee' => {
						'calling_convention' => '_stdcall '
					},
					'RelinquishInterface' => {
						'calling_convention' => '_stdcall '
					},
					'RestoreInterface' => {
						'calling_convention' => '_stdcall '
					},
					'ConnectAsAggregatee' => {
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IDirectorySearch' => {
				'pretty_print_order' => bless( do{\(my $o = '+34')}, 'Math::BigInt' ),
				'isa' => [
					'IDirectorySearch',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '109BA8EC-92F0-11D0-A790-00C04FD8D5A8'
				},
				'methods' => {
					'CloseSearchHandle' => {
						'args' => [
							'void* hSearchResult'
						],
						'calling_convention' => '_stdcall '
					},
					'ExecuteSearch' => {
						'args' => [
							'LPWSTR pszSearchFilter',
							'LPWSTR* pAttributeNames',
							'unsigned long dwNumberAttributes'
						],
						'returns' => [
							'void** phSearchResult'
						],
						'calling_convention' => '_stdcall '
					},
					'GetColumn' => {
						'args' => [
							'void* hSearchResult',
							'LPWSTR szColumnName'
						],
						'returns' => [
							'ads_search_column* pSearchColumn'
						],
						'calling_convention' => '_stdcall '
					},
					'GetNextRow' => {
						'args' => [
							'void* hSearchResult'
						],
						'calling_convention' => '_stdcall '
					},
					'AbandonSearch' => {
						'args' => [
							'void* phSearchResult'
						],
						'calling_convention' => '_stdcall '
					},
					'SetSearchPreference' => {
						'args' => [
							'ads_searchpref_info* pSearchPrefs',
							'unsigned long dwNumPrefs'
						],
						'calling_convention' => '_stdcall '
					},
					'GetPreviousRow' => {
						'args' => [
							'void* hSearchResult'
						],
						'calling_convention' => '_stdcall '
					},
					'GetFirstRow' => {
						'args' => [
							'void* hSearchResult'
						],
						'calling_convention' => '_stdcall '
					},
					'FreeColumn' => {
						'args' => [
							'ads_search_column* pSearchColumn'
						],
						'calling_convention' => '_stdcall '
					},
					'GetNextColumnName' => {
						'args' => [
							'void* hSearchHandle'
						],
						'returns' => [
							'LPWSTR* ppszColumnName'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsFileService' => {
				'pretty_print_order' => bless( do{\(my $o = '+12015080053775104')}, 'Math::BigInt' ),
				'isa' => [
					'IADsFileService',
					'IADsService',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'A89D1900-31CA-11CF-A98A-00AA006BC149'
				},
				'properties' => {
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000021'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'MaxUserCount' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000022'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADsService'
			},
			'IADsHold' => {
				'coclass' => 'Hold',
				'pretty_print_order' => bless( do{\(my $o = '+8132')}, 'Math::BigInt' ),
				'isa' => [
					'IADsHold',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B3EB3B37-4080-11D1-A3AC-00C04FB950DC'
				},
				'properties' => {
					'ObjectName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Amount' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsObjectOptions' => {
				'pretty_print_order' => bless( do{\(my $o = '+10412')}, 'Math::BigInt' ),
				'isa' => [
					'IADsObjectOptions',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '46F14FDA-232B-11D1-A808-00C04FD8D5A8'
				},
				'methods' => {
					'GetOption' => {
						'args' => [
							'long lnOption'
						],
						'returns' => [
							'VARIANT* pvValue'
						],
						'attributes' => {
							'id' => '0x00000002'
						}
					},
					'SetOption' => {
						'args' => [
							'long lnOption',
							'VARIANT vValue'
						],
						'attributes' => {
							'id' => '0x00000003'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IDirectoryObject' => {
				'pretty_print_order' => bless( do{\(my $o = '+22')}, 'Math::BigInt' ),
				'isa' => [
					'IDirectoryObject',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => 'E798DE2C-22E4-11D0-84FE-00C04FD8D503'
				},
				'methods' => {
					'SetObjectAttributes' => {
						'args' => [
							'_ads_attr_info* pAttributeEntries',
							'unsigned long dwNumAttributes'
						],
						'returns' => [
							'unsigned long* pdwNumAttributesModified'
						],
						'calling_convention' => '_stdcall '
					},
					'DeleteDSObject' => {
						'args' => [
							'LPWSTR pszRDNName'
						],
						'calling_convention' => '_stdcall '
					},
					'GetObjectInformation' => {
						'returns' => [
							'_ads_object_info** ppObjInfo'
						],
						'calling_convention' => '_stdcall '
					},
					'GetObjectAttributes' => {
						'args' => [
							'LPWSTR* pAttributeNames',
							'unsigned long dwNumberAttributes'
						],
						'returns' => [
							'_ads_attr_info** ppAttributeEntries',
							'unsigned long* pdwNumAttributesReturned'
						],
						'calling_convention' => '_stdcall '
					},
					'CreateDSObject' => {
						'args' => [
							'LPWSTR pszRDNName',
							'_ads_attr_info* pAttributeEntries',
							'unsigned long dwNumAttributes'
						],
						'returns' => [
							'IDispatch** ppObject'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsPrintJobOperations' => {
				'pretty_print_order' => bless( do{\(my $o = '+92352464')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPrintJobOperations',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '9A52DB30-1ECF-11CF-A988-00AA006BC149'
				},
				'methods' => {
					'Resume' => {
						'attributes' => {
							'id' => '0x0000001f'
						}
					},
					'Pause' => {
						'attributes' => {
							'id' => '0x0000001e'
						}
					}
				},
				'properties' => {
					'Position' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001d'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'TimeElapsed' => {
						'attributes' => {
							'id' => '0x0000001b'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'PagesPrinted' => {
						'attributes' => {
							'id' => '0x0000001c'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Status' => {
						'attributes' => {
							'id' => '0x0000001a'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsOpenDSObject' => {
				'pretty_print_order' => bless( do{\(my $o = '+11324')}, 'Math::BigInt' ),
				'isa' => [
					'IADsOpenDSObject',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'DDF2891E-0F9C-11D0-8AD4-00C04FD8D503'
				},
				'methods' => {
					'OpenDSObject' => {
						'args' => [
							'BSTR lpszDNName',
							'BSTR lpszUserName',
							'BSTR lpszPassword',
							'long lnReserved'
						],
						'returns' => [
							'IDispatch** ppOleDsObj'
						],
						'attributes' => {
							'id' => '0x00000001'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsPostalAddress' => {
				'coclass' => 'PostalAddress',
				'pretty_print_order' => bless( do{\(my $o = '+12388')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPostalAddress',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '7ADECF29-4680-11D1-A3B4-00C04FB950DC'
				},
				'properties' => {
					'PostalAddress' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsFileShare' => {
				'pretty_print_order' => bless( do{\(my $o = '+79402672')}, 'Math::BigInt' ),
				'isa' => [
					'IADsFileShare',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'EB6DCAF0-4B83-11CF-A995-00AA006BC149'
				},
				'properties' => {
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'HostComputer' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'CurrentUserCount' => {
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'MaxUserCount' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Path' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsPropertyValue2' => {
				'pretty_print_order' => bless( do{\(my $o = '+13756')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPropertyValue2',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '306E831C-5BC7-11D1-A3B8-00C04FB950DC'
				},
				'methods' => {
					'GetObjectProperty' => {
						'args' => [
							'long* lnADsType'
						],
						'returns' => [
							'long* lnADsType',
							'VARIANT* pvProp'
						],
						'attributes' => {
							'id' => '0x00000001'
						}
					},
					'PutObjectProperty' => {
						'args' => [
							'long lnADsType',
							'VARIANT vProp'
						],
						'attributes' => {
							'id' => '0x00000002'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsAcl' => {
				'coclass' => 'Acl',
				'pretty_print_order' => bless( do{\(my $o = '+5396')}, 'Math::BigInt' ),
				'isa' => [
					'IADsAcl',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '8452D3AB-0869-11D1-A377-00C04FB950DC'
				},
				'methods' => {
					'CopyAcl' => {
						'returns' => [
							'IDispatch** ppAcl'
						],
						'attributes' => {
							'id' => '0x00000005'
						}
					}
				},
				'properties' => {
					'SubjectName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Privileges' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'ProtectedAttrName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsAccessControlEntry' => {
				'coclass' => 'AccessControlEntry',
				'pretty_print_order' => bless( do{\(my $o = '+4636')}, 'Math::BigInt' ),
				'isa' => [
					'IADsAccessControlEntry',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B4F3A14C-9BDD-11D0-852C-00C04FD8D503'
				},
				'properties' => {
					'ObjectType' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000006'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Flags' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000005'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'InheritedObjectType' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000007'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'AceFlags' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Trustee' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000008'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'AceType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'AccessMask' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IPicture' => {
				'pretty_print_order' => bless( do{\(my $o = '+62')}, 'Math::BigInt' ),
				'isa' => [
					'IPicture',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'helpstring' => '"Picture Object"',
					'hidden' => undef,
					'uuid' => '7BF80980-BF32-101A-8BBB-00AA00300CAB'
				},
				'methods' => {
					'Render' => {
						'args' => [
							'int hdc',
							'long x',
							'long y',
							'long cx',
							'long cy',
							'OLE_XPOS_HIMETRIC xSrc',
							'OLE_YPOS_HIMETRIC ySrc',
							'OLE_XSIZE_HIMETRIC cxSrc',
							'OLE_YSIZE_HIMETRIC cySrc',
							'void* prcWBounds'
						],
						'calling_convention' => '_stdcall '
					},
					'PictureChanged' => {
						'calling_convention' => '_stdcall '
					},
					'SelectPicture' => {
						'args' => [
							'int hdcIn'
						],
						'returns' => [
							'int* phdcOut',
							'OLE_HANDLE* phbmpOut'
						],
						'calling_convention' => '_stdcall '
					},
					'SaveAsFile' => {
						'args' => [
							'void* pstm',
							'VARIANT_BOOL fSaveMemCopy'
						],
						'returns' => [
							'long* pcbSize'
						],
						'calling_convention' => '_stdcall '
					},
					'SetHdc' => {
						'args' => [
							'OLE_HANDLE hdc'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'properties' => {
					'Height' => {
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'OLE_YSIZE_HIMETRIC* pheight'
							]
						}
					},
					'Handle' => {
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'OLE_HANDLE* phandle'
							]
						}
					},
					'KeepOriginalFormat' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL pfkeep'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'VARIANT_BOOL* pfkeep'
							]
						}
					},
					'CurDC' => {
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'int* phdcOut'
							]
						}
					},
					'Attributes' => {
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'long* pdwAttr'
							]
						}
					},
					'hPal' => {
						'set' => {
							'args' => [
								'OLE_HANDLE phpal'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'OLE_HANDLE* phpal'
							]
						}
					},
					'Width' => {
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'OLE_XSIZE_HIMETRIC* pwidth'
							]
						}
					},
					'Type' => {
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'short* ptype'
							]
						}
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsServiceOperations' => {
				'pretty_print_order' => bless( do{\(my $o = '+105983824')}, 'Math::BigInt' ),
				'isa' => [
					'IADsServiceOperations',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '5D7B33F0-31CA-11CF-A98A-00AA006BC149'
				},
				'methods' => {
					'Continue' => {
						'attributes' => {
							'id' => '0x0000001f'
						}
					},
					'Start' => {
						'attributes' => {
							'id' => '0x0000001c'
						}
					},
					'SetPassword' => {
						'args' => [
							'BSTR bstrNewPassword'
						],
						'attributes' => {
							'id' => '0x00000020'
						}
					},
					'Stop' => {
						'attributes' => {
							'id' => '0x0000001d'
						}
					},
					'Pause' => {
						'attributes' => {
							'id' => '0x0000001e'
						}
					}
				},
				'properties' => {
					'Status' => {
						'attributes' => {
							'id' => '0x0000001b'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsGroup' => {
				'pretty_print_order' => bless( do{\(my $o = '+81447376')}, 'Math::BigInt' ),
				'isa' => [
					'IADsGroup',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '27636B00-410F-11CF-B1FF-02608C9E7553'
				},
				'methods' => {
					'Remove' => {
						'args' => [
							'BSTR bstrItemToBeRemoved'
						],
						'attributes' => {
							'id' => '0x00000013'
						}
					},
					'IsMember' => {
						'args' => [
							'BSTR bstrMember'
						],
						'returns' => [
							'VARIANT_BOOL* bMember'
						],
						'attributes' => {
							'id' => '0x00000011'
						}
					},
					'Members' => {
						'returns' => [
							'IADsMembers** ppMembers'
						],
						'attributes' => {
							'id' => '0x00000010'
						}
					},
					'Add' => {
						'args' => [
							'BSTR bstrNewItem'
						],
						'attributes' => {
							'id' => '0x00000012'
						}
					}
				},
				'properties' => {
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'ITypeComp' => {
				'pretty_print_order' => bless( do{\(my $o = '+86')}, 'Math::BigInt' ),
				'isa' => [
					'ITypeComp',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '00020403-0000-0000-C000-000000000046'
				},
				'methods' => {
					'RemoteBind' => {
						'args' => [
							'LPWSTR szName',
							'unsigned long lHashVal',
							'unsigned short wFlags'
						],
						'returns' => [
							'ITypeInfo** ppTInfo',
							'tagDESCKIND* pDescKind',
							'tagFUNCDESC** ppFuncDesc',
							'tagVARDESC** ppVarDesc',
							'ITypeComp** ppTypeComp',
							'DWORD* pDummy'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteBindType' => {
						'args' => [
							'LPWSTR szName',
							'unsigned long lHashVal'
						],
						'returns' => [
							'ITypeInfo** ppTInfo'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsLocality' => {
				'pretty_print_order' => bless( do{\(my $o = '+82128944')}, 'Math::BigInt' ),
				'isa' => [
					'IADsLocality',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'A05E03A2-EFFE-11CF-8ABC-00C04FD8D503'
				},
				'properties' => {
					'LocalityName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PostalAddress' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'SeeAlso' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsExtension' => {
				'pretty_print_order' => bless( do{\(my $o = '+14')}, 'Math::BigInt' ),
				'isa' => [
					'IADsExtension',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '3D35553C-D2B0-11D1-B17B-0000F87593A0'
				},
				'methods' => {
					'Operate' => {
						'args' => [
							'unsigned long dwCode',
							'VARIANT varData1',
							'VARIANT varData2',
							'VARIANT varData3'
						],
						'calling_convention' => '_stdcall '
					},
					'PrivateInvoke' => {
						'args' => [
							'long dispidMember',
							'GUID* riid',
							'unsigned long lcid',
							'unsigned short wFlags',
							'DISPPARAMS* pDispParams'
						],
						'returns' => [
							'VARIANT* pVarResult',
							'EXCEPINFO* pExcepInfo',
							'unsigned int* puArgErr'
						],
						'calling_convention' => '_stdcall '
					},
					'PrivateGetIDsOfNames' => {
						'args' => [
							'GUID* riid',
							'short** rgszNames',
							'unsigned int cNames',
							'unsigned long lcid'
						],
						'returns' => [
							'long* rgdispid'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsNamespaces' => {
				'pretty_print_order' => bless( do{\(my $o = '+85536784')}, 'Math::BigInt' ),
				'isa' => [
					'IADsNamespaces',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '28B96BA0-B330-11CF-A9AD-00AA006BC149'
				},
				'properties' => {
					'DefaultContainer' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000001'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsProperty' => {
				'pretty_print_order' => bless( do{\(my $o = '+96441872')}, 'Math::BigInt' ),
				'isa' => [
					'IADsProperty',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'C8F93DD3-4AE0-11CF-9E73-00AA004A5691'
				},
				'methods' => {
					'Qualifiers' => {
						'returns' => [
							'IADsCollection** ppQualifiers'
						],
						'attributes' => {
							'id' => '0x00000016'
						}
					}
				},
				'properties' => {
					'Syntax' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'OID' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'MaxRange' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'MultiValued' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'MinRange' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsOctetList' => {
				'coclass' => 'OctetList',
				'pretty_print_order' => bless( do{\(my $o = '+10564')}, 'Math::BigInt' ),
				'isa' => [
					'IADsOctetList',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '7B28B80F-4680-11D1-A3B4-00C04FB950DC'
				},
				'properties' => {
					'OctetList' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsUser' => {
				'pretty_print_order' => bless( do{\(my $o = '+112799504')}, 'Math::BigInt' ),
				'isa' => [
					'IADsUser',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '3E37E320-17E2-11CF-ABC4-02608C9E7553'
				},
				'methods' => {
					'ChangePassword' => {
						'args' => [
							'BSTR bstrOldPassword',
							'BSTR bstrNewPassword'
						],
						'attributes' => {
							'id' => '0x00000044'
						}
					},
					'SetPassword' => {
						'args' => [
							'BSTR NewPassword'
						],
						'attributes' => {
							'id' => '0x00000043'
						}
					},
					'Groups' => {
						'returns' => [
							'IADsMembers** ppGroups'
						],
						'attributes' => {
							'id' => '0x00000042'
						}
					}
				},
				'properties' => {
					'Description' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PasswordMinimumLength' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000032'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'LoginHours' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000002d'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'PostalAddresses' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001e'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'AccountExpirationDate' => {
						'set' => {
							'args' => [
								'DATE retval'
							]
						},
						'attributes' => {
							'id' => '0x00000026'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'TelephoneMobile' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000021'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'Profile' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000003f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'BadLoginAddress' => {
						'attributes' => {
							'id' => '0x00000035'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'RequireUniquePassword' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000034'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'LoginWorkstations' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000002e'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'MaxStorage' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000030'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Manager' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001a'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'OfficeLocations' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001c'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'PostalCodes' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001f'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'FullName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000017'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'MaxLogins' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x0000002f'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'AccountDisabled' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000025'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'Languages' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000003e'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'Division' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'BadLoginCount' => {
						'attributes' => {
							'id' => '0x00000036'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Department' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000007a'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Picture' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000041'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'TelephoneNumber' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000022'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'FirstName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000016'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'EmployeeID' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'NamePrefix' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000072'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'GraceLoginsRemaining' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x0000002a'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'OtherName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001b'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'EmailAddress' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000003c'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'NameSuffix' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000073'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'SeeAlso' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000075'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'IsAccountLocked' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x0000002b'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'LastName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000019'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Title' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000024'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'TelephoneHome' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000020'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'TelephonePager' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'LastLogoff' => {
						'attributes' => {
							'id' => '0x00000039'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'GraceLoginsAllowed' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000029'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'PasswordLastChanged' => {
						'attributes' => {
							'id' => '0x0000003b'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'FaxNumber' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'HomeDirectory' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000003d'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PasswordExpirationDate' => {
						'set' => {
							'args' => [
								'DATE retval'
							]
						},
						'attributes' => {
							'id' => '0x00000031'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'LastLogin' => {
						'attributes' => {
							'id' => '0x00000038'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'LastFailedLogin' => {
						'attributes' => {
							'id' => '0x0000003a'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'HomePage' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000078'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'LoginScript' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000040'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'PasswordRequired' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000033'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsTypedName' => {
				'coclass' => 'TypedName',
				'pretty_print_order' => bless( do{\(my $o = '+15124')}, 'Math::BigInt' ),
				'isa' => [
					'IADsTypedName',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B371A349-4080-11D1-A3AC-00C04FB950DC'
				},
				'properties' => {
					'ObjectName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Interval' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Level' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsFaxNumber' => {
				'coclass' => 'FaxNumber',
				'pretty_print_order' => bless( do{\(my $o = '+7828')}, 'Math::BigInt' ),
				'isa' => [
					'IADsFaxNumber',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'A910DEA9-4680-11D1-A3B4-00C04FB950DC'
				},
				'properties' => {
					'Parameters' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'TelephoneNumber' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsPathname' => {
				'coclass' => 'Pathname',
				'pretty_print_order' => bless( do{\(my $o = '+11932')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPathname',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'D592AED4-F420-11D0-A36E-00C04FB950DC'
				},
				'properties' => {
					'EscapedMode' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000b'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'methods' => {
					'SetDisplayType' => {
						'args' => [
							'long lnDisplayType'
						],
						'attributes' => {
							'id' => '0x00000003'
						}
					},
					'Set' => {
						'args' => [
							'BSTR bstrADsPath',
							'long lnSetType'
						],
						'attributes' => {
							'id' => '0x00000002'
						}
					},
					'AddLeafElement' => {
						'args' => [
							'BSTR bstrLeafElement'
						],
						'attributes' => {
							'id' => '0x00000007'
						}
					},
					'Retrieve' => {
						'args' => [
							'long lnFormatType'
						],
						'returns' => [
							'BSTR* pbstrADsPath'
						],
						'attributes' => {
							'id' => '0x00000004'
						}
					},
					'GetNumElements' => {
						'returns' => [
							'long* plnNumPathElements'
						],
						'attributes' => {
							'id' => '0x00000005'
						}
					},
					'GetEscapedElement' => {
						'args' => [
							'long lnReserved',
							'BSTR bstrInStr'
						],
						'returns' => [
							'BSTR* pbstrOutStr'
						],
						'attributes' => {
							'id' => '0x0000000a'
						}
					},
					'GetElement' => {
						'args' => [
							'long lnElementIndex'
						],
						'returns' => [
							'BSTR* pbstrElement'
						],
						'attributes' => {
							'id' => '0x00000006'
						}
					},
					'CopyPath' => {
						'returns' => [
							'IDispatch** ppAdsPath'
						],
						'attributes' => {
							'id' => '0x00000009'
						}
					},
					'RemoveLeafElement' => {
						'attributes' => {
							'id' => '0x00000008'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsEmail' => {
				'coclass' => 'Email',
				'pretty_print_order' => bless( do{\(my $o = '+7676')}, 'Math::BigInt' ),
				'isa' => [
					'IADsEmail',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '97AF011A-478E-11D1-A3B4-00C04FB950DC'
				},
				'properties' => {
					'Address' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Type' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsLargeInteger' => {
				'coclass' => 'LargeInteger',
				'pretty_print_order' => bless( do{\(my $o = '+8284')}, 'Math::BigInt' ),
				'isa' => [
					'IADsLargeInteger',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '9068270B-0939-11D1-8BE1-00C04FD8D503'
				},
				'properties' => {
					'LowPart' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'HighPart' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsComputerOperations' => {
				'pretty_print_order' => bless( do{\(my $o = '+77357968')}, 'Math::BigInt' ),
				'isa' => [
					'IADsComputerOperations',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'EF497680-1D9F-11CF-B1F3-02608C9E7553'
				},
				'methods' => {
					'Shutdown' => {
						'args' => [
							'VARIANT_BOOL bReboot'
						],
						'attributes' => {
							'id' => '0x00000022'
						}
					},
					'Status' => {
						'returns' => [
							'IDispatch** ppObject'
						],
						'attributes' => {
							'id' => '0x00000021'
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsMembers' => {
				'pretty_print_order' => bless( do{\(my $o = '+8588')}, 'Math::BigInt' ),
				'isa' => [
					'IADsMembers',
					'IDispatch',
					'IUnknown'