#!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'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '451A0030-72EC-11CF-B03B-00AA006E0975'
				},
				'properties' => {
					'_NewEnum' => {
						'attributes' => {
							'id' => '0xfffffffc'
						},
						'get' => {
							'returns' => [
								'IUnknown** ppEnumerator'
							]
						}
					},
					'Count' => {
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* plCount'
							]
						}
					},
					'Filter' => {
						'set' => {
							'args' => [
								'VARIANT pvFilter'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'VARIANT* pvFilter'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IFont' => {
				'pretty_print_order' => bless( do{\(my $o = '+58')}, 'Math::BigInt' ),
				'isa' => [
					'IFont',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'helpstring' => '"Font Object"',
					'hidden' => undef,
					'uuid' => 'BEF6E002-A874-101A-8BBA-00AA00300CAB'
				},
				'methods' => {
					'IsEqual' => {
						'args' => [
							'IFont* pfontOther'
						],
						'calling_convention' => '_stdcall '
					},
					'ReleaseHfont' => {
						'args' => [
							'OLE_HANDLE hFont'
						],
						'calling_convention' => '_stdcall '
					},
					'AddRefHfont' => {
						'args' => [
							'OLE_HANDLE hFont'
						],
						'calling_convention' => '_stdcall '
					},
					'Clone' => {
						'returns' => [
							'IFont** ppfont'
						],
						'calling_convention' => '_stdcall '
					},
					'SetRatio' => {
						'args' => [
							'long cyLogical',
							'long cyHimetric'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'properties' => {
					'Weight' => {
						'set' => {
							'args' => [
								'short pweight'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'short* pweight'
							]
						}
					},
					'Strikethrough' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL pstrikethrough'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'VARIANT_BOOL* pstrikethrough'
							]
						}
					},
					'Name' => {
						'set' => {
							'args' => [
								'BSTR pname'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'BSTR* pname'
							]
						}
					},
					'Italic' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL pitalic'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'VARIANT_BOOL* pitalic'
							]
						}
					},
					'Underline' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL punderline'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'VARIANT_BOOL* punderline'
							]
						}
					},
					'hFont' => {
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'OLE_HANDLE* phfont'
							]
						}
					},
					'Size' => {
						'set' => {
							'args' => [
								'CURRENCY psize'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'CURRENCY* psize'
							]
						}
					},
					'Bold' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL pbold'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'VARIANT_BOOL* pbold'
							]
						}
					},
					'Charset' => {
						'set' => {
							'args' => [
								'short pcharset'
							]
						},
						'calling_convention' => '_stdcall ',
						'get' => {
							'returns' => [
								'short* pcharset'
							]
						}
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsPropertyValue' => {
				'pretty_print_order' => bless( do{\(my $o = '+13604')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPropertyValue',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '79FA9AD0-A97C-11D0-8534-00C04FD8D503'
				},
				'properties' => {
					'PrintableString' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000006'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Integer' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000009'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'ADsType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'DNString' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'UTCTime' => {
						'set' => {
							'args' => [
								'DATE retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000d'
						},
						'get' => {
							'returns' => [
								'DATE* retval'
							]
						}
					},
					'LargeInteger' => {
						'set' => {
							'args' => [
								'IDispatch* retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000c'
						},
						'get' => {
							'returns' => [
								'IDispatch** retval'
							]
						}
					},
					'CaseIgnoreString' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000005'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'NumericString' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000007'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Boolean' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000008'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'OctetString' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000a'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'SecurityDescriptor' => {
						'set' => {
							'args' => [
								'IDispatch* retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000b'
						},
						'get' => {
							'returns' => [
								'IDispatch** retval'
							]
						}
					},
					'CaseExactString' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'methods' => {
					'Clear' => {
						'attributes' => {
							'id' => '0x00000001'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsPrintQueueOperations' => {
				'pretty_print_order' => bless( do{\(my $o = '+95760304')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPrintQueueOperations',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '124BE5C0-156E-11CF-A986-00AA006BC149'
				},
				'methods' => {
					'Resume' => {
						'attributes' => {
							'id' => '0x0000001e'
						}
					},
					'Purge' => {
						'attributes' => {
							'id' => '0x0000001f'
						}
					},
					'Pause' => {
						'attributes' => {
							'id' => '0x0000001d'
						}
					},
					'PrintJobs' => {
						'returns' => [
							'IADsCollection** pObject'
						],
						'attributes' => {
							'id' => '0x0000001c'
						}
					}
				},
				'properties' => {
					'Status' => {
						'attributes' => {
							'id' => '0x0000001b'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsClass' => {
				'pretty_print_order' => bless( do{\(my $o = '+71905424')}, 'Math::BigInt' ),
				'isa' => [
					'IADsClass',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'C8F93DD0-4AE0-11CF-9E73-00AA004A5691'
				},
				'methods' => {
					'Qualifiers' => {
						'returns' => [
							'IADsCollection** ppQualifiers'
						],
						'attributes' => {
							'id' => '0x00000019'
						}
					}
				},
				'properties' => {
					'HelpFileContext' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000018'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'OptionalProperties' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001d'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'MandatoryProperties' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'PossibleSuperiors' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001c'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'AuxDerivedFrom' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001b'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'Container' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000016'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'CLSID' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'OID' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Abstract' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'Auxiliary' => {
						'set' => {
							'args' => [
								'VARIANT_BOOL retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001a'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'HelpFileName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000017'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'NamingProperties' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001e'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'Containment' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'DerivedFrom' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'PrimaryInterface' => {
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsO' => {
				'pretty_print_order' => bless( do{\(my $o = '+87581488')}, 'Math::BigInt' ),
				'isa' => [
					'IADsO',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'A1CD2DC6-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'
							]
						}
					},
					'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'
			},
			'IADsDomain' => {
				'pretty_print_order' => bless( do{\(my $o = '+78039536')}, 'Math::BigInt' ),
				'isa' => [
					'IADsDomain',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '00E4C220-FD16-11CE-ABC4-02608C9E7553'
				},
				'properties' => {
					'PasswordHistoryLength' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'AutoUnlockInterval' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000016'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'MaxBadPasswordsAllowed' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'MaxPasswordAge' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'MinPasswordAge' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'LockoutObservationInterval' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000017'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'PasswordAttributes' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'IsWorkgroup' => {
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'VARIANT_BOOL* retval'
							]
						}
					},
					'MinPasswordLength' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IUnknown' => {
				'pretty_print_order' => bless( do{\(my $o = '+2')}, 'Math::BigInt' ),
				'isa' => [
					'IUnknown'
				]
			},
			'IPrivateUnknown' => {
				'pretty_print_order' => bless( do{\(my $o = '+82')}, 'Math::BigInt' ),
				'isa' => [
					'IPrivateUnknown',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '89126BAB-6EAD-11D1-8C18-00C04FD8D503'
				},
				'methods' => {
					'ADSIReleaseObject' => {
						'calling_convention' => '_stdcall '
					},
					'ADSIInitializeObject' => {
						'args' => [
							'BSTR lpszUserName',
							'BSTR lpszPassword',
							'long lnReserved'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsService' => {
				'pretty_print_order' => bless( do{\(my $o = '+104620688')}, 'Math::BigInt' ),
				'isa' => [
					'IADsService',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '68AF66E0-31CA-11CF-A98A-00AA006BC149'
				},
				'properties' => {
					'ServiceType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'StartupParameters' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000015'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'DisplayName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'LoadOrderGroup' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000017'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'ServiceAccountPath' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000019'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'HostComputer' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'ErrorControl' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000016'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Version' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Dependencies' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x0000001a'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'ServiceAccountName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000018'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'StartType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Path' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			},
			'IADsDeleteOps' => {
				'pretty_print_order' => bless( do{\(my $o = '+7372')}, 'Math::BigInt' ),
				'isa' => [
					'IADsDeleteOps',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B2BD0902-8878-11D1-8C21-00C04FD8D503'
				},
				'methods' => {
					'DeleteObject' => {
						'args' => [
							'long lnFlags'
						],
						'attributes' => {
							'id' => '0x00000002'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsPropertyList' => {
				'pretty_print_order' => bless( do{\(my $o = '+13148')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPropertyList',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'C6F602B6-8F69-11D0-8528-00C04FD8D503'
				},
				'methods' => {
					'PutPropertyItem' => {
						'args' => [
							'VARIANT varData'
						],
						'attributes' => {
							'id' => '0x00000007'
						}
					},
					'GetPropertyItem' => {
						'args' => [
							'BSTR bstrName',
							'long lnADsType'
						],
						'returns' => [
							'VARIANT* pVariant'
						],
						'attributes' => {
							'id' => '0x00000006'
						}
					},
					'Item' => {
						'args' => [
							'VARIANT varIndex'
						],
						'returns' => [
							'VARIANT* pVariant'
						],
						'attributes' => {
							'id' => '00000000'
						}
					},
					'Skip' => {
						'args' => [
							'long cElements'
						],
						'attributes' => {
							'id' => '0x00000004'
						}
					},
					'PurgePropertyList' => {
						'attributes' => {
							'id' => '0x00000009'
						}
					},
					'Reset' => {
						'attributes' => {
							'id' => '0x00000005'
						}
					},
					'ResetPropertyItem' => {
						'args' => [
							'VARIANT varEntry'
						],
						'attributes' => {
							'id' => '0x00000008'
						}
					},
					'Next' => {
						'returns' => [
							'VARIANT* pVariant'
						],
						'attributes' => {
							'id' => '0x00000003'
						}
					}
				},
				'properties' => {
					'PropertyCount' => {
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* plCount'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsContainer' => {
				'pretty_print_order' => bless( do{\(my $o = '+6764')}, 'Math::BigInt' ),
				'isa' => [
					'IADsContainer',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '001677D0-FD16-11CE-ABC4-02608C9E7553'
				},
				'methods' => {
					'Create' => {
						'args' => [
							'BSTR ClassName',
							'BSTR RelativeName'
						],
						'returns' => [
							'IDispatch** ppObject'
						],
						'attributes' => {
							'id' => '0x00000006'
						}
					},
					'GetObject' => {
						'args' => [
							'BSTR ClassName',
							'BSTR RelativeName'
						],
						'returns' => [
							'IDispatch** ppObject'
						],
						'attributes' => {
							'id' => '0x00000005'
						}
					},
					'MoveHere' => {
						'args' => [
							'BSTR SourceName',
							'BSTR NewName'
						],
						'returns' => [
							'IDispatch** ppObject'
						],
						'attributes' => {
							'id' => '0x00000009'
						}
					},
					'CopyHere' => {
						'args' => [
							'BSTR SourceName',
							'BSTR NewName'
						],
						'returns' => [
							'IDispatch** ppObject'
						],
						'attributes' => {
							'id' => '0x00000008'
						}
					},
					'Delete' => {
						'args' => [
							'BSTR bstrClassName',
							'BSTR bstrRelativeName'
						],
						'attributes' => {
							'id' => '0x00000007'
						}
					}
				},
				'properties' => {
					'_NewEnum' => {
						'attributes' => {
							'id' => '0xfffffffc',
							'restricted' => undef
						},
						'get' => {
							'returns' => [
								'IUnknown** retval'
							]
						}
					},
					'Hints' => {
						'set' => {
							'args' => [
								'VARIANT pvFilter'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'VARIANT* pvFilter'
							]
						}
					},
					'Count' => {
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Filter' => {
						'set' => {
							'args' => [
								'VARIANT pVar'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'VARIANT* pVar'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsFileServiceOperations' => {
				'pretty_print_order' => bless( do{\(my $o = '+12532804242871552')}, 'Math::BigInt' ),
				'isa' => [
					'IADsFileServiceOperations',
					'IADsServiceOperations',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'A02DED10-31CA-11CF-A98A-00AA006BC149'
				},
				'methods' => {
					'Resources' => {
						'returns' => [
							'IADsCollection** ppResources'
						],
						'attributes' => {
							'id' => '0x00000024'
						}
					},
					'Sessions' => {
						'returns' => [
							'IADsCollection** ppSessions'
						],
						'attributes' => {
							'id' => '0x00000023'
						}
					}
				},
				'extends' => 'IADsServiceOperations'
			},
			'IADsPath' => {
				'coclass' => 'Path',
				'pretty_print_order' => bless( do{\(my $o = '+11476')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPath',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => 'B287FCD5-4080-11D1-A3AC-00C04FB950DC'
				},
				'properties' => {
					'Type' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'VolumeName' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'Path' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IADsPropertyEntry' => {
				'coclass' => 'PropertyEntry',
				'pretty_print_order' => bless( do{\(my $o = '+12692')}, 'Math::BigInt' ),
				'isa' => [
					'IADsPropertyEntry',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '05792C8E-941F-11D0-8529-00C04FD8D503'
				},
				'properties' => {
					'Values' => {
						'set' => {
							'args' => [
								'VARIANT retval'
							]
						},
						'attributes' => {
							'id' => '0x00000005'
						},
						'get' => {
							'returns' => [
								'VARIANT* retval'
							]
						}
					},
					'ControlCode' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000004'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'ADsType' => {
						'set' => {
							'args' => [
								'long retval'
							]
						},
						'attributes' => {
							'id' => '0x00000003'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Name' => {
						'set' => {
							'args' => [
								'BSTR retval'
							]
						},
						'attributes' => {
							'id' => '0x00000002'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					}
				},
				'methods' => {
					'Clear' => {
						'attributes' => {
							'id' => '0x00000001'
						}
					}
				},
				'extends' => 'IDispatch'
			},
			'IPrivateDispatch' => {
				'pretty_print_order' => bless( do{\(my $o = '+74')}, 'Math::BigInt' ),
				'isa' => [
					'IPrivateDispatch',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '86AB4BBE-65F6-11D1-8C13-00C04FD8D503'
				},
				'methods' => {
					'ADSIGetTypeInfo' => {
						'args' => [
							'unsigned int itinfo',
							'unsigned long lcid'
						],
						'returns' => [
							'ITypeInfo** ppTInfo'
						],
						'calling_convention' => '_stdcall '
					},
					'ADSIInitializeDispatchManager' => {
						'args' => [
							'long dwExtensionId'
						],
						'calling_convention' => '_stdcall '
					},
					'ADSIInvoke' => {
						'args' => [
							'long dispidMember',
							'GUID* riid',
							'unsigned long lcid',
							'unsigned short wFlags',
							'DISPPARAMS* pDispParams'
						],
						'returns' => [
							'VARIANT* pVarResult',
							'EXCEPINFO* pExcepInfo',
							'unsigned int* puArgErr'
						],
						'calling_convention' => '_stdcall '
					},
					'ADSIGetTypeInfoCount' => {
						'returns' => [
							'unsigned int* pctinfo'
						],
						'calling_convention' => '_stdcall '
					},
					'ADSIGetIDsOfNames' => {
						'args' => [
							'GUID* riid',
							'short** rgszNames',
							'unsigned int cNames',
							'unsigned long lcid'
						],
						'returns' => [
							'long* rgdispid'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IDispatch' => {
				'pretty_print_order' => bless( do{\(my $o = '+38')}, 'Math::BigInt' ),
				'isa' => [
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'restricted' => undef,
					'uuid' => '00020400-0000-0000-C000-000000000046'
				},
				'methods' => {
					'GetIDsOfNames' => {
						'args' => [
							'GUID* riid',
							'char** rgszNames',
							'unsigned int cNames',
							'unsigned long lcid'
						],
						'returns' => [
							'long* rgdispid'
						],
						'attributes' => {
							'restricted' => undef
						},
						'calling_convention' => '_stdcall '
					},
					'GetTypeInfo' => {
						'args' => [
							'unsigned int itinfo',
							'unsigned long lcid'
						],
						'returns' => [
							'void** pptinfo'
						],
						'attributes' => {
							'restricted' => undef
						},
						'calling_convention' => '_stdcall '
					},
					'GetTypeInfoCount' => {
						'returns' => [
							'unsigned int* pctinfo'
						],
						'attributes' => {
							'restricted' => undef
						},
						'calling_convention' => '_stdcall '
					},
					'Invoke' => {
						'args' => [
							'long dispidMember',
							'GUID* riid',
							'unsigned long lcid',
							'unsigned short wFlags',
							'DISPPARAMS* pdispparams'
						],
						'returns' => [
							'VARIANT* pvarResult',
							'EXCEPINFO* pexcepinfo',
							'unsigned int* puArgErr'
						],
						'attributes' => {
							'restricted' => undef
						},
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IDirectorySchemaMgmt' => {
				'pretty_print_order' => bless( do{\(my $o = '+26')}, 'Math::BigInt' ),
				'isa' => [
					'IDirectorySchemaMgmt',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '75DB3B9C-A4D8-11D0-A79C-00C04FD8D5A8'
				},
				'methods' => {
					'WriteAttributeDefinition' => {
						'calling_convention' => '_stdcall '
					},
					'CreateClassDefinition' => {
						'calling_convention' => '_stdcall '
					},
					'CreateAttributeDefinition' => {
						'calling_convention' => '_stdcall '
					},
					'WriteClassDefinition' => {
						'calling_convention' => '_stdcall '
					},
					'DeleteAttributeDefinition' => {
						'calling_convention' => '_stdcall '
					},
					'EnumAttributes' => {
						'calling_convention' => '_stdcall '
					},
					'DeleteClassDefinition' => {
						'calling_convention' => '_stdcall '
					},
					'EnumClasses' => {
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'ITypeInfo' => {
				'pretty_print_order' => bless( do{\(my $o = '+94')}, 'Math::BigInt' ),
				'isa' => [
					'ITypeInfo',
					'IUnknown'
				],
				'attributes' => {
					'odl' => undef,
					'uuid' => '00020401-0000-0000-C000-000000000046'
				},
				'methods' => {
					'GetContainingTypeLib' => {
						'returns' => [
							'ITypeLib** ppTLib',
							'unsigned int* pIndex'
						],
						'calling_convention' => '_stdcall '
					},
					'GetTypeComp' => {
						'returns' => [
							'ITypeComp** ppTComp'
						],
						'calling_convention' => '_stdcall '
					},
					'LocalReleaseFuncDesc' => {
						'calling_convention' => '_stdcall '
					},
					'RemoteGetTypeAttr' => {
						'returns' => [
							'tagTYPEATTR** ppTypeAttr',
							'DWORD* pDummy'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteCreateInstance' => {
						'args' => [
							'_GUID* riid'
						],
						'returns' => [
							'IUnknown** ppvObj'
						],
						'calling_convention' => '_stdcall '
					},
					'LocalAddressOfMember' => {
						'calling_convention' => '_stdcall '
					},
					'RemoteGetDllEntry' => {
						'args' => [
							'long memid',
							'tagINVOKEKIND invkind',
							'unsigned long refPtrFlags'
						],
						'returns' => [
							'BSTR* pBstrDllName',
							'BSTR* pBstrName',
							'unsigned short* pwOrdinal'
						],
						'calling_convention' => '_stdcall '
					},
					'LocalReleaseVarDesc' => {
						'calling_convention' => '_stdcall '
					},
					'GetIDsOfNames' => {
						'args' => [
							'LPWSTR* rgszNames',
							'unsigned int cNames'
						],
						'returns' => [
							'long* pMemId'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteGetFuncDesc' => {
						'args' => [
							'unsigned int index'
						],
						'returns' => [
							'tagFUNCDESC** ppFuncDesc',
							'DWORD* pDummy'
						],
						'calling_convention' => '_stdcall '
					},
					'GetRefTypeOfImplType' => {
						'args' => [
							'unsigned int index'
						],
						'returns' => [
							'unsigned long* pRefType'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteGetVarDesc' => {
						'args' => [
							'unsigned int index'
						],
						'returns' => [
							'tagVARDESC** ppVarDesc',
							'DWORD* pDummy'
						],
						'calling_convention' => '_stdcall '
					},
					'LocalReleaseTypeAttr' => {
						'calling_convention' => '_stdcall '
					},
					'GetNames' => {
						'args' => [
							'long memid',
							'unsigned int cMaxNames'
						],
						'returns' => [
							'BSTR* rgBstrNames',
							'unsigned int* pcNames'
						],
						'calling_convention' => '_stdcall '
					},
					'GetImplTypeFlags' => {
						'args' => [
							'unsigned int index'
						],
						'returns' => [
							'int* pImplTypeFlags'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteGetDocumentation' => {
						'args' => [
							'long memid',
							'unsigned long refPtrFlags'
						],
						'returns' => [
							'BSTR* pBstrName',
							'BSTR* pBstrDocString',
							'unsigned long* pdwHelpContext',
							'BSTR* pBstrHelpFile'
						],
						'calling_convention' => '_stdcall '
					},
					'GetMops' => {
						'args' => [
							'long memid'
						],
						'returns' => [
							'BSTR* pBstrMops'
						],
						'calling_convention' => '_stdcall '
					},
					'RemoteInvoke' => {
						'args' => [
							'IUnknown* pIUnk',
							'long memid',
							'unsigned long dwFlags',
							'DISPPARAMS* pDispParams',
							'unsigned int cVtRef'
						],
						'returns' => [
							'VARIANT* rgVtRef',
							'VARIANT* pVarResult',
							'EXCEPINFO* pExcepInfo',
							'unsigned int* pArgErr'
						],
						'calling_convention' => '_stdcall '
					},
					'GetRefTypeInfo' => {
						'args' => [
							'unsigned long hreftype'
						],
						'returns' => [
							'ITypeInfo** ppTInfo'
						],
						'calling_convention' => '_stdcall '
					}
				},
				'extends' => 'IUnknown'
			},
			'IADsSession' => {
				'pretty_print_order' => bless( do{\(my $o = '+106665392')}, 'Math::BigInt' ),
				'isa' => [
					'IADsSession',
					'IADs',
					'IDispatch',
					'IUnknown'
				],
				'attributes' => {
					'oleautomation' => undef,
					'odl' => undef,
					'dual' => undef,
					'uuid' => '398B7DA0-4AAB-11CF-AE2C-00AA006EBFB9'
				},
				'properties' => {
					'ComputerPath' => {
						'attributes' => {
							'id' => '0x00000012'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'UserPath' => {
						'attributes' => {
							'id' => '0x00000010'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'ConnectTime' => {
						'attributes' => {
							'id' => '0x00000013'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					},
					'Computer' => {
						'attributes' => {
							'id' => '0x00000011'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'User' => {
						'attributes' => {
							'id' => '0x0000000f'
						},
						'get' => {
							'returns' => [
								'BSTR* retval'
							]
						}
					},
					'IdleTime' => {
						'attributes' => {
							'id' => '0x00000014'
						},
						'get' => {
							'returns' => [
								'long* retval'
							]
						}
					}
				},
				'extends' => 'IADs'
			}
		},{
			'A89D1900-31CA-11CF-A98A-00AA006BC149' => 'IADsFileService',
			'B2BD0902-8878-11D1-8C21-00C04FD8D503' => 'IADsDeleteOps',
			'A05E03A2-EFFE-11CF-8ABC-00C04FD8D503' => 'IADsLocality',
			'00020403-0000-0000-C000-000000000046' => 'ITypeComp',
			'B8C787CA-9BDD-11D0-852C-00C04FD8D503' => 'IADsSecurityDescriptor',
			'C8F93DD0-4AE0-11CF-9E73-00AA004A5691' => 'IADsClass',
			'109BA8EC-92F0-11D0-A790-00C04FD8D5A8' => 'IDirectorySearch',
			'B21A50A9-4080-11D1-A3AC-00C04FB950DC' => 'IADsNetAddress',
			'89126BAB-6EAD-11D1-8C18-00C04FD8D503' => 'IPrivateUnknown',
			'00E4C220-FD16-11CE-ABC4-02608C9E7553' => 'IADsDomain',
			'52DB5FB0-941F-11D0-8529-00C04FD8D503' => 'IADsAggregator',
			'7B28B80F-4680-11D1-A3B4-00C04FB950DC' => 'IADsOctetList',
			'306E831C-5BC7-11D1-A3B8-00C04FB950DC' => 'IADsPropertyValue2',
			'F60FB803-4080-11D1-A3AC-00C04FB950DC' => 'IADsReplicaPointer',
			'75DB3B9C-A4D8-11D0-A79C-00C04FD8D5A8' => 'IDirectorySchemaMgmt',
			'C6F602B6-8F69-11D0-8528-00C04FD8D503' => 'IADsPropertyList',
			'C8F93DD3-4AE0-11CF-9E73-00AA004A5691' => 'IADsProperty',
			'E798DE2C-22E4-11D0-84FE-00C04FD8D503' => 'IDirectoryObject',
			'00020402-0000-0000-C000-000000000046' => 'ITypeLib',
			'D592AED4-F420-11D0-A36E-00C04FB950DC' => 'IADsPathname',
			'A910DEA9-4680-11D1-A3B4-00C04FB950DC' => 'IADsFaxNumber',
			'7B66B533-4680-11D1-A3B4-00C04FB950DC' => 'IADsCaseIgnoreList',
			'A2F733B8-EFFE-11CF-8ABC-00C04FD8D503' => 'IADsOU',
			'8452D3AB-0869-11D1-A377-00C04FB950DC' => 'IADsAcl',
			'DDF2891E-0F9C-11D0-8AD4-00C04FD8D503' => 'IADsOpenDSObject',
			'28B96BA0-B330-11CF-A9AD-00AA006BC149' => 'IADsNamespaces',
			'7BF80980-BF32-101A-8BBB-00AA00300CAB' => 'IPicture',
			'3E37E320-17E2-11CF-ABC4-02608C9E7553' => 'IADsUser',
			'7ADECF29-4680-11D1-A3B4-00C04FB950DC' => 'IADsPostalAddress',
			'34A05B20-4AAB-11CF-AE2C-00AA006EBFB9' => 'IADsResource',
			'B7EE91CC-9BDD-11D0-852C-00C04FD8D503' => 'IADsAccessControlList',
			'3D35553C-D2B0-11D1-B17B-0000F87593A0' => 'IADsExtension',
			'05792C8E-941F-11D0-8529-00C04FD8D503' => 'IADsPropertyEntry',
			'B4F3A14C-9BDD-11D0-852C-00C04FD8D503' => 'IADsAccessControlEntry',
			'001677D0-FD16-11CE-ABC4-02608C9E7553' => 'IADsContainer',
			'72B945E0-253B-11CF-A988-00AA006BC149' => 'IADsCollection',
			'68AF66E0-31CA-11CF-A98A-00AA006BC149' => 'IADsService',
			'C8F93DD2-4AE0-11CF-9E73-00AA004A5691' => 'IADsSyntax',
			'FD8256D0-FD15-11CE-ABC4-02608C9E7553' => 'IADs',
			'5D7B33F0-31CA-11CF-A98A-00AA006BC149' => 'IADsServiceOperations',
			'97AF011A-478E-11D1-A3B4-00C04FB950DC' => 'IADsEmail',
			'00020401-0000-0000-C000-000000000046' => 'ITypeInfo',
			'EFE3CC70-1D9F-11CF-B1F3-02608C9E7553' => 'IADsComputer',
			'A02DED10-31CA-11CF-A98A-00AA006BC149' => 'IADsFileServiceOperations',
			'124BE5C0-156E-11CF-A986-00AA006BC149' => 'IADsPrintQueueOperations',
			'32FB6780-1ED0-11CF-A988-00AA006BC149' => 'IADsPrintJob',
			'B2F5A901-4080-11D1-A3AC-00C04FB950DC' => 'IADsTimestamp',
			'B1B272A3-3625-11D1-A3A4-00C04FB950DC' => 'IADsNameTranslate',
			'FD1302BD-4080-11D1-A3AC-00C04FB950DC' => 'IADsBackLink',
			'451A0030-72EC-11CF-B03B-00AA006E0975' => 'IADsMembers',
			'B371A349-4080-11D1-A3AC-00C04FB950DC' => 'IADsTypedName',
			'9A52DB30-1ECF-11CF-A988-00AA006BC149' => 'IADsPrintJobOperations',
			'B287FCD5-4080-11D1-A3AC-00C04FB950DC' => 'IADsPath',
			'79FA9AD0-A97C-11D0-8534-00C04FD8D503' => 'IADsPropertyValue',
			'00020404-0000-0000-C000-000000000046' => 'IEnumVARIANT',
			'B3EB3B37-4080-11D1-A3AC-00C04FB950DC' => 'IADsHold',
			'A1CD2DC6-EFFE-11CF-8ABC-00C04FD8D503' => 'IADsO',
			'398B7DA0-4AAB-11CF-AE2C-00AA006EBFB9' => 'IADsSession',
			'9068270B-0939-11D1-8BE1-00C04FD8D503' => 'IADsLargeInteger',
			'46F14FDA-232B-11D1-A808-00C04FD8D5A8' => 'IADsObjectOptions',
			'86AB4BBE-65F6-11D1-8C13-00C04FD8D503' => 'IPrivateDispatch',
			'EB6DCAF0-4B83-11CF-A995-00AA006BC149' => 'IADsFileShare',
			'27636B00-410F-11CF-B1FF-02608C9E7553' => 'IADsGroup',
			'00020400-0000-0000-C000-000000000046' => 'IDispatch',
			'1346CE8C-9039-11D0-8528-00C04FD8D503' => 'IADsAggregatee',
			'BEF6E002-A874-101A-8BBA-00AA00300CAB' => 'IFont',
			'EF497680-1D9F-11CF-B1F3-02608C9E7553' => 'IADsComputerOperations',
			'B15160D0-1226-11CF-A985-00AA006BC149' => 'IADsPrintQueue',
		},
	);
}



# data below generated from using OLE/COM viewer on activeds.tlb (type lib)
# and then copy/pasting output for the imported stdole2.tlb
# ...not elegant, but hey, it got the job done ;)

__DATA__


// Generated .IDL file (by the OLE/COM Object Viewer)
// 
// typelib filename: <could not determine filename>

[
  uuid(97D25DB0-0363-11CF-ABC4-02608C9E7553),
  version(1.0),
  helpstring("Active DS Type Library")
]
library ActiveDs
{
    // TLib :     // TLib : OLE Automation : {00020430-0000-0000-C000-000000000046}
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!  BEGIN  !!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");


				    // TLib :     // Forward declare all types defined in this typelib
				    interface IUnknown;
				    interface IDispatch;
				    interface IEnumVARIANT;
				    interface IFont;
				    dispinterface Font;
				    interface IPicture;
				    dispinterface Picture;
				    dispinterface FontEvents;

				    typedef struct tagGUID {
				                
				unsigned long Data1;
				                
				unsigned short Data2;
				                
				unsigned short Data3;
				                
				unsigned char Data4[8];
				    } GUID;

				    typedef struct tagDISPPARAMS {
				                
				VARIANT* rgvarg;
				                
				long* rgdispidNamedArgs;
				                
				unsigned int cArgs;
				                
				unsigned int cNamedArgs;
				    } DISPPARAMS;

				    typedef struct tagEXCEPINFO {
				                
				unsigned short wCode;
				                
				unsigned short wReserved;
				                
				BSTR bstrSource;
				                
				BSTR bstrDescription;
				                
				BSTR bstrHelpFile;
				                
				unsigned long dwHelpContext;
				                
				void* pvReserved;
				                
				void* pfnDeferredFillIn;
				                
				SCODE scode;
				    } EXCEPINFO;

				    [
				      odl,
				      uuid(00000000-0000-0000-C000-000000000046),
				      hidden
				    ]
				    interface IUnknown {
				    };

				    [
				      odl,
				      uuid(00020400-0000-0000-C000-000000000046),
				      restricted
				    ]
				    interface IDispatch : IUnknown {
				        [restricted]
				        HRESULT _stdcall GetTypeInfoCount([out] unsigned int* pctinfo);
				        [restricted]
				        HRESULT _stdcall GetTypeInfo(
				                        [in] unsigned int itinfo, 
				                        [in] unsigned long lcid, 
				                        [out] void** pptinfo);
				        [restricted]
				        HRESULT _stdcall GetIDsOfNames(
				                        [in] GUID* riid, 
				                        [in] char** rgszNames, 
				                        [in] unsigned int cNames, 
				                        [in] unsigned long lcid, 
				                        [out] long* rgdispid);
				        [restricted]
				        HRESULT _stdcall Invoke(
				                        [in] long dispidMember, 
				                        [in] GUID* riid, 
				                        [in] unsigned long lcid, 
				                        [in] unsigned short wFlags, 
				                        [in] DISPPARAMS* pdispparams, 
				                        [out] VARIANT* pvarResult, 
				                        [out] EXCEPINFO* pexcepinfo, 
				                        [out] unsigned int* puArgErr);
				    };

				    [
				      odl,
				      uuid(00020404-0000-0000-C000-000000000046),
				      hidden
				    ]
				    interface IEnumVARIANT : IUnknown {
				        HRESULT _stdcall Next(
				                        [in] unsigned long celt, 
				                        [in] VARIANT* rgvar, 
				                        [out] unsigned long* pceltFetched);
				        HRESULT _stdcall Skip([in] unsigned long celt);
				        HRESULT _stdcall Reset();
				        HRESULT _stdcall Clone([out] IEnumVARIANT** ppenum);
				    };

				    typedef [uuid(66504301-BE0F-101A-8BBB-00AA00300CAB), public]
				    unsigned long OLE_COLOR;

				    typedef [uuid(66504302-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_XPOS_PIXELS;

				    typedef [uuid(66504303-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_YPOS_PIXELS;

				    typedef [uuid(66504304-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_XSIZE_PIXELS;

				    typedef [uuid(66504305-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_YSIZE_PIXELS;

				    typedef [uuid(66504306-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_XPOS_HIMETRIC;

				    typedef [uuid(66504307-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_YPOS_HIMETRIC;

				    typedef [uuid(66504308-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_XSIZE_HIMETRIC;

				    typedef [uuid(66504309-BE0F-101A-8BBB-00AA00300CAB), public]
				    long OLE_YSIZE_HIMETRIC;

				    typedef [uuid(BF030640-9069-101B-AE2D-08002B2EC713), public]
				    single OLE_XPOS_CONTAINER;

				    typedef [uuid(BF030641-9069-101B-AE2D-08002B2EC713), public]
				    single OLE_YPOS_CONTAINER;

				    typedef [uuid(BF030642-9069-101B-AE2D-08002B2EC713), public]
				    single OLE_XSIZE_CONTAINER;

				    typedef [uuid(BF030643-9069-101B-AE2D-08002B2EC713), public]
				    single OLE_YSIZE_CONTAINER;

				    typedef [uuid(66504313-BE0F-101A-8BBB-00AA00300CAB), public]
				    int OLE_HANDLE;

				    typedef [uuid(6650430B-BE0F-101A-8BBB-00AA00300CAB), public]
				    VARIANT_BOOL OLE_OPTEXCLUSIVE;

				    typedef [uuid(BF030644-9069-101B-AE2D-08002B2EC713), public]
				    VARIANT_BOOL OLE_CANCELBOOL;

				    typedef [uuid(BF030645-9069-101B-AE2D-08002B2EC713), public]
				    VARIANT_BOOL OLE_ENABLEDEFAULTBOOL;

				    typedef [uuid(6650430A-BE0F-101A-8BBB-00AA00300CAB)]
				    enum {
				        Unchecked = 0,
				        Checked = 1,
				        Gray = 2
				    } OLE_TRISTATE;

				    typedef [uuid(6650430D-BE0F-101A-8BBB-00AA00300CAB), public]
				    BSTR FONTNAME;

				    typedef [uuid(6650430E-BE0F-101A-8BBB-00AA00300CAB), public]
				    CURRENCY FONTSIZE;

				    typedef [uuid(6650430F-BE0F-101A-8BBB-00AA00300CAB), public]
				    VARIANT_BOOL FONTBOLD;

				    typedef [uuid(66504310-BE0F-101A-8BBB-00AA00300CAB), public]
				    VARIANT_BOOL FONTITALIC;

				    typedef [uuid(66504311-BE0F-101A-8BBB-00AA00300CAB), public]
				    VARIANT_BOOL FONTUNDERSCORE;

				    typedef [uuid(66504312-BE0F-101A-8BBB-00AA00300CAB), public]
				    VARIANT_BOOL FONTSTRIKETHROUGH;

				    [
				      odl,
				      uuid(BEF6E002-A874-101A-8BBA-00AA00300CAB),
				      helpstring("Font Object"),
				      hidden
				    ]
				    interface IFont : IUnknown {
				        [propget]
				        HRESULT _stdcall Name([out, retval] BSTR* pname);
				        [propput]
				        HRESULT _stdcall Name([in] BSTR pname);
				        [propget]
				        HRESULT _stdcall Size([out, retval] CURRENCY* psize);
				        [propput]
				        HRESULT _stdcall Size([in] CURRENCY psize);
				        [propget]
				        HRESULT _stdcall Bold([out, retval] VARIANT_BOOL* pbold);
				        [propput]
				        HRESULT _stdcall Bold([in] VARIANT_BOOL pbold);
				        [propget]
				        HRESULT _stdcall Italic([out, retval] VARIANT_BOOL* pitalic);
				        [propput]
				        HRESULT _stdcall Italic([in] VARIANT_BOOL pitalic);
				        [propget]
				        HRESULT _stdcall Underline([out, retval] VARIANT_BOOL* punderline);
				        [propput]
				        HRESULT _stdcall Underline([in] VARIANT_BOOL punderline);
				        [propget]
				        HRESULT _stdcall Strikethrough([out, retval] VARIANT_BOOL* pstrikethrough);
				        [propput]
				        HRESULT _stdcall Strikethrough([in] VARIANT_BOOL pstrikethrough);
				        [propget]
				        HRESULT _stdcall Weight([out, retval] short* pweight);
				        [propput]
				        HRESULT _stdcall Weight([in] short pweight);
				        [propget]
				        HRESULT _stdcall Charset([out, retval] short* pcharset);
				        [propput]
				        HRESULT _stdcall Charset([in] short pcharset);
				        [propget]
				        HRESULT _stdcall hFont([out, retval] OLE_HANDLE* phfont);
				        HRESULT _stdcall Clone([out] IFont** ppfont);
				        HRESULT _stdcall IsEqual([in] IFont* pfontOther);
				        HRESULT _stdcall SetRatio(
				                        [in] long cyLogical, 
				                        [in] long cyHimetric);
				        HRESULT _stdcall AddRefHfont([in] OLE_HANDLE hFont);
				        HRESULT _stdcall ReleaseHfont([in] OLE_HANDLE hFont);
				    };

				    [
				      uuid(BEF6E003-A874-101A-8BBA-00AA00300CAB)
				    ]
				    dispinterface Font {
				        properties:
				            [id(00000000)            
				]
				            BSTR Name;
				            [id(0x00000002)            
				]
				            CURRENCY Size;
				            [id(0x00000003)            
				]
				            VARIANT_BOOL Bold;
				            [id(0x00000004)            
				]
				            VARIANT_BOOL Italic;
				            [id(0x00000005)            
				]
				            VARIANT_BOOL Underline;
				            [id(0x00000006)            
				]
				            VARIANT_BOOL Strikethrough;
				            [id(0x00000007)            
				]
				            short Weight;
				            [id(0x00000008)            
				]
				            short Charset;
				        methods:
				    };

				    typedef [public]
				    Font IFontDisp;

				    [
				      uuid(0BE35203-8F91-11CE-9DE3-00AA004BB851)
				    ]
				    coclass StdFont {
				        [default] dispinterface Font;
				        [default, source] dispinterface FontEvents;
				        interface IFont;
				    };

				    [
				      odl,
				      uuid(7BF80980-BF32-101A-8BBB-00AA00300CAB),
				      helpstring("Picture Object"),
				      hidden
				    ]
				    interface IPicture : IUnknown {
				        [propget]
				        HRESULT _stdcall Handle([out, retval] OLE_HANDLE* phandle);
				        [propget]
				        HRESULT _stdcall hPal([out, retval] OLE_HANDLE* phpal);
				        [propget]
				        HRESULT _stdcall Type([out, retval] short* ptype);
				        [propget]
				        HRESULT _stdcall Width([out, retval] OLE_XSIZE_HIMETRIC* pwidth);
				        [propget]
				        HRESULT _stdcall Height([out, retval] OLE_YSIZE_HIMETRIC* pheight);
				        HRESULT _stdcall Render(
				                        [in] int hdc, 
				                        [in] long x, 
				                        [in] long y, 
				                        [in] long cx, 
				                        [in] long cy, 
				                        [in] OLE_XPOS_HIMETRIC xSrc, 
				                        [in] OLE_YPOS_HIMETRIC ySrc, 
				                        [in] OLE_XSIZE_HIMETRIC cxSrc, 
				                        [in] OLE_YSIZE_HIMETRIC cySrc, 
				                        [in] void* prcWBounds);
				        [propput]
				        HRESULT _stdcall hPal([in] OLE_HANDLE phpal);
				        [propget]
				        HRESULT _stdcall CurDC([out, retval] int* phdcOut);
				        HRESULT _stdcall SelectPicture(
				                        [in] int hdcIn, 
				                        [out] int* phdcOut, 
				                        [out] OLE_HANDLE* phbmpOut);
				        [propget]
				        HRESULT _stdcall KeepOriginalFormat([out, retval] VARIANT_BOOL* pfkeep);
				        [propput]
				        HRESULT _stdcall KeepOriginalFormat([in] VARIANT_BOOL pfkeep);
				        HRESULT _stdcall PictureChanged();
				        HRESULT _stdcall SaveAsFile(
				                        [in] void* pstm, 
				                        [in] VARIANT_BOOL fSaveMemCopy, 
				                        [out] long* pcbSize);
				        [propget]
				        HRESULT _stdcall Attributes([out, retval] long* pdwAttr);
				        HRESULT _stdcall SetHdc([in] OLE_HANDLE hdc);
				    };

				    [
				      uuid(7BF80981-BF32-101A-8BBB-00AA00300CAB)
				    ]
				    dispinterface Picture {
				        properties:
				            [id(00000000), readonly            
				]
				            OLE_HANDLE Handle;
				            [id(0x00000002)            
				]
				            OLE_HANDLE hPal;
				            [id(0x00000003), readonly            
				]
				            short Type;
				            [id(0x00000004), readonly            
				]
				            OLE_XSIZE_HIMETRIC Width;
				            [id(0x00000005), readonly            
				]
				            OLE_YSIZE_HIMETRIC Height;
				        methods:
				            [id(0x00000006)]
				            void Render(
				                            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);
				    };

				    typedef [public]
				    Picture IPictureDisp;

				    [
				      uuid(0BE35204-8F91-11CE-9DE3-00AA004BB851)
				    ]
				    coclass StdPicture {
				        [default] dispinterface Picture;
				        interface IPicture;
				    };

				    typedef [uuid(E6C8FA08-BD9F-11D0-985E-00C04FC29993)]
				    enum {
				        Default = 0,
				        Monochrome = 1,
				        VgaColor = 2,
				        Color = 4
				    } LoadPictureConstants;

				    [
				      dllname("oleaut32.dll"),
				      uuid(91209AC0-60F6-11CF-9C5D-00AA00C1489E),
				      helpstring("Functions for Standard OLE Objects"),
				      helpcontext(0x00002775)
				    ]
				    module StdFunctions {
				        [entry(0x60000000), helpstring("Loads a picture from a file"), helpcontext(0x00002775)]
				        HRESULT _stdcall LoadPicture(
				                        [in, optional] VARIANT filename, 
				                        [in, optional, defaultvalue(0)] int widthDesired, 
				                        [in, optional, defaultvalue(0)] int heightDesired, 
				                        [in, optional, defaultvalue(0)] LoadPictureConstants flags, 
				                        [out, retval] IPictureDisp** retval);
				        [entry(0x60000001), helpstring("Saves a picture to a file"), helpcontext(0x00002775)]
				        HRESULT _stdcall SavePicture(
				                        [in] IPictureDisp* Picture, 
				                        [in] BSTR filename);
				    };

				    [
				      uuid(4EF6100A-AF88-11D0-9846-00C04FC29993),
				      helpstring("Event interface for the Font object"),
				      hidden
				    ]
				    dispinterface FontEvents {
				        properties:
				        methods:
				            [id(0x00000009)]
				            void FontChanged([in] BSTR PropertyName);
				    };

				    typedef [public]
				    FontEvents IFontEventsDisp;


// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!   END   !!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!    importlib("StdOle2.tlb");
    // Forward declare all types defined in this typelib
    interface IADs;
    interface IADsContainer;
    interface IADsCollection;
    interface IADsMembers;
    interface IADsPropertyList;
    interface IADsPropertyEntry;
    interface IADsPropertyValue;
    interface IADsPropertyValue2;
    interface IPrivateDispatch;
    interface ITypeInfo;
    interface ITypeComp;
    interface ITypeLib;
    interface IPrivateUnknown;
    interface IADsExtension;
    interface IADsDeleteOps;
    interface IADsNamespaces;
    interface IADsClass;
    interface IADsProperty;
    interface IADsSyntax;
    interface IADsLocality;
    interface IADsO;
    interface IADsOU;
    interface IADsDomain;
    interface IADsComputer;
    interface IADsComputerOperations;
    interface IADsGroup;
    interface IADsUser;
    interface IADsPrintQueue;
    interface IADsPrintQueueOperations;
    interface IADsPrintJob;
    interface IADsPrintJobOperations;
    interface IADsService;
    interface IADsServiceOperations;
    interface IADsFileService;
    interface IADsFileServiceOperations;
    interface IADsFileShare;
    interface IADsSession;
    interface IADsResource;
    interface IADsOpenDSObject;
    interface IDirectoryObject;
    interface IDirectorySearch;
    interface IDirectorySchemaMgmt;
    interface IADsAggregatee;
    interface IADsAggregator;
    interface IADsAccessControlEntry;
    interface IADsAccessControlList;
    interface IADsSecurityDescriptor;
    interface IADsLargeInteger;
    interface IADsNameTranslate;
    interface IADsCaseIgnoreList;
    interface IADsFaxNumber;
    interface IADsNetAddress;
    interface IADsOctetList;
    interface IADsEmail;
    interface IADsPath;
    interface IADsReplicaPointer;
    interface IADsAcl;
    interface IADsTimestamp;
    interface IADsPostalAddress;
    interface IADsBackLink;
    interface IADsTypedName;
    interface IADsHold;
    interface IADsObjectOptions;
    interface IADsPathname;

    typedef [public]
    __MIDL___MIDL__intf_0000_0001 ADSTYPEENUM;

    typedef enum {
        ADSTYPE_INVALID = 0,
        ADSTYPE_DN_STRING = 1,
        ADSTYPE_CASE_EXACT_STRING = 2,
        ADSTYPE_CASE_IGNORE_STRING = 3,
        ADSTYPE_PRINTABLE_STRING = 4,
        ADSTYPE_NUMERIC_STRING = 5,
        ADSTYPE_BOOLEAN = 6,
        ADSTYPE_INTEGER = 7,
        ADSTYPE_OCTET_STRING = 8,
        ADSTYPE_UTC_TIME = 9,
        ADSTYPE_LARGE_INTEGER = 10,
        ADSTYPE_PROV_SPECIFIC = 11,
        ADSTYPE_OBJECT_CLASS = 12,
        ADSTYPE_CASEIGNORE_LIST = 13,
        ADSTYPE_OCTET_LIST = 14,
        ADSTYPE_PATH = 15,
        ADSTYPE_POSTALADDRESS = 16,
        ADSTYPE_TIMESTAMP = 17,
        ADSTYPE_BACKLINK = 18,
        ADSTYPE_TYPEDNAME = 19,
        ADSTYPE_HOLD = 20,
        ADSTYPE_NETADDRESS = 21,
        ADSTYPE_REPLICAPOINTER = 22,
        ADSTYPE_FAXNUMBER = 23,
        ADSTYPE_EMAIL = 24,
        ADSTYPE_NT_SECURITY_DESCRIPTOR = 25,
        ADSTYPE_UNKNOWN = 26
    } __MIDL___MIDL__intf_0000_0001;

    typedef [public]
    __MIDL___MIDL__intf_0000_0002 ADS_OCTET_STRING;

    typedef struct tag__MIDL___MIDL__intf_0000_0002 {
                
unsigned long dwLength;
                
unsigned char* lpValue;
    } __MIDL___MIDL__intf_0000_0002;

    typedef [public]
    __MIDL___MIDL__intf_0000_0003 ADS_NT_SECURITY_DESCRIPTOR;

    typedef struct tag__MIDL___MIDL__intf_0000_0003 {
                
unsigned long dwLength;
                
unsigned char* lpValue;
    } __MIDL___MIDL__intf_0000_0003;

    typedef struct tag_SYSTEMTIME {
                
unsigned short wYear;
                
unsigned short wMonth;
                
unsigned short wDayOfWeek;
                
unsigned short wDay;
                
unsigned short wHour;
                
unsigned short wMinute;
                
unsigned short wSecond;
                
unsigned short wMilliseconds;
    } _SYSTEMTIME;

    typedef struct tag_LARGE_INTEGER {
                
int64 QuadPart;
    } _LARGE_INTEGER;

    typedef [public]
    __MIDL___MIDL__intf_0000_0004 ADS_PROV_SPECIFIC;

    typedef struct tag__MIDL___MIDL__intf_0000_0004 {
                
unsigned long dwLength;
                
unsigned char* lpValue;
    } __MIDL___MIDL__intf_0000_0004;

    typedef struct tag_ADS_CASEIGNORE_LIST {
                
_ADS_CASEIGNORE_LIST* Next;
                
LPWSTR String;
    } _ADS_CASEIGNORE_LIST;

    typedef struct tag_ADS_OCTET_LIST {
                
_ADS_OCTET_LIST* Next;
                
unsigned long Length;
                
unsigned char* Data;
    } _ADS_OCTET_LIST;

    typedef [public]
    __MIDL___MIDL__intf_0000_0005 ADS_PATH;

    typedef struct tag__MIDL___MIDL__intf_0000_0005 {
                
unsigned long Type;
                
LPWSTR VolumeName;
                
LPWSTR Path;
    } __MIDL___MIDL__intf_0000_0005;

    typedef [public]
    __MIDL___MIDL__intf_0000_0006 ADS_POSTALADDRESS;

    typedef struct tag__MIDL___MIDL__intf_0000_0006 {
                
LPWSTR PostalAddress[6];
    } __MIDL___MIDL__intf_0000_0006;

    typedef [public]
    __MIDL___MIDL__intf_0000_0007 ADS_TIMESTAMP;

    typedef struct tag__MIDL___MIDL__intf_0000_0007 {
                
unsigned long WholeSeconds;
                
unsigned long EventID;
    } __MIDL___MIDL__intf_0000_0007;

    typedef [public]
    __MIDL___MIDL__intf_0000_0008 ADS_BACKLINK;

    typedef struct tag__MIDL___MIDL__intf_0000_0008 {
                
unsigned long RemoteID;
                
LPWSTR ObjectName;
    } __MIDL___MIDL__intf_0000_0008;

    typedef [public]
    __MIDL___MIDL__intf_0000_0009 ADS_TYPEDNAME;

    typedef struct tag__MIDL___MIDL__intf_0000_0009 {
                
LPWSTR ObjectName;
                
unsigned long Level;
                
unsigned long Interval;
    } __MIDL___MIDL__intf_0000_0009;

    typedef [public]
    __MIDL___MIDL__intf_0000_0010 ADS_HOLD;

    typedef struct tag__MIDL___MIDL__intf_0000_0010 {
                
LPWSTR ObjectName;
                
unsigned long Amount;
    } __MIDL___MIDL__intf_0000_0010;

    typedef [public]
    __MIDL___MIDL__intf_0000_0011 ADS_NETADDRESS;

    typedef struct tag__MIDL___MIDL__intf_0000_0011 {
                
unsigned long AddressType;
                
unsigned long AddressLength;
                
unsigned char* Address;
    } __MIDL___MIDL__intf_0000_0011;

    typedef [public]
    __MIDL___MIDL__intf_0000_0012 ADS_REPLICAPOINTER;

    typedef struct tag__MIDL___MIDL__intf_0000_0012 {
                
LPWSTR ServerName;
                
unsigned long ReplicaType;
                
unsigned long ReplicaNumber;
                
unsigned long Count;
                
__MIDL___MIDL__intf_0000_0011* ReplicaAddressHints;
    } __MIDL___MIDL__intf_0000_0012;

    typedef [public]
    __MIDL___MIDL__intf_0000_0013 ADS_FAXNUMBER;

    typedef struct tag__MIDL___MIDL__intf_0000_0013 {
                
LPWSTR TelephoneNumber;
                
unsigned long NumberOfBits;
                
unsigned char* Parameters;
    } __MIDL___MIDL__intf_0000_0013;

    typedef [public]
    __MIDL___MIDL__intf_0000_0014 ADS_EMAIL;

    typedef struct tag__MIDL___MIDL__intf_0000_0014 {
                
LPWSTR Address;
                
unsigned long Type;
    } __MIDL___MIDL__intf_0000_0014;

    typedef struct tag_adsvalue {
                
ADSTYPEENUM dwType;
                
__MIDL___MIDL__intf_0000_0015 __MIDL_0015;
    } _adsvalue;

    typedef union tag__MIDL___MIDL__intf_0000_0015 {
                
LPWSTR DNString;
                
LPWSTR CaseExactString;
                
LPWSTR CaseIgnoreString;
                
LPWSTR PrintableString;
                
LPWSTR NumericString;
                
unsigned long Boolean;
                
unsigned long Integer;
                
ADS_OCTET_STRING OctetString;
                
_SYSTEMTIME UTCTime;
                
_LARGE_INTEGER LargeInteger;
                
LPWSTR ClassName;
                
ADS_PROV_SPECIFIC ProviderSpecific;
                
_ADS_CASEIGNORE_LIST* pCaseIgnoreList;
                
_ADS_OCTET_LIST* pOctetList;
                
__MIDL___MIDL__intf_0000_0005* pPath;
                
__MIDL___MIDL__intf_0000_0006* pPostalAddress;
                
ADS_TIMESTAMP Timestamp;
                
ADS_BACKLINK BackLink;
                
__MIDL___MIDL__intf_0000_0009* pTypedName;
                
ADS_HOLD Hold;
                
__MIDL___MIDL__intf_0000_0011* pNetAddress;
                
__MIDL___MIDL__intf_0000_0012* pReplicaPointer;
                
__MIDL___MIDL__intf_0000_0013* pFaxNumber;
                
ADS_EMAIL Email;
                
ADS_NT_SECURITY_DESCRIPTOR SecurityDescriptor;
    } __MIDL___MIDL__intf_0000_0015;

    typedef struct tag_ads_attr_info {
                
LPWSTR pszAttrName;
                
unsigned long dwControlCode;
                
ADSTYPEENUM dwADsType;
                
_adsvalue* pADsValues;
                
unsigned long dwNumValues;
    } _ads_attr_info;

    typedef [public]
    __MIDL___MIDL__intf_0000_0016 ADS_AUTHENTICATION_ENUM;

    typedef enum {
        ADS_SECURE_AUTHENTICATION = 1,
        ADS_USE_ENCRYPTION = 2,
        ADS_USE_SSL = 2,
        ADS_READONLY_SERVER = 4,
        ADS_PROMPT_CREDENTIALS = 8,
        ADS_NO_AUTHENTICATION = 16,
        ADS_FAST_BIND = 32,
        ADS_USE_SIGNING = 64,
        ADS_USE_SEALING = 128
    } __MIDL___MIDL__intf_0000_0016;

    typedef struct tag_ads_object_info {
                
LPWSTR pszRDN;
                
LPWSTR pszObjectDN;
                
LPWSTR pszParentDN;
                
LPWSTR pszSchemaDN;
                
LPWSTR pszClassName;
    } _ads_object_info;

    typedef [public]
    __MIDL___MIDL__intf_0000_0017 ADS_STATUSENUM;

    typedef enum {
        ADS_STATUS_S_OK = 0,
        ADS_STATUS_INVALID_SEARCHPREF = 1,
        ADS_STATUS_INVALID_SEARCHPREFVALUE = 2
    } __MIDL___MIDL__intf_0000_0017;

    typedef [public]
    __MIDL___MIDL__intf_0000_0018 ADS_DEREFENUM;

    typedef enum {
        ADS_DEREF_NEVER = 0,
        ADS_DEREF_SEARCHING = 1,
        ADS_DEREF_FINDING = 2,
        ADS_DEREF_ALWAYS = 3
    } __MIDL___MIDL__intf_0000_0018;

    typedef [public]
    __MIDL___MIDL__intf_0000_0019 ADS_SCOPEENUM;

    typedef enum {
        ADS_SCOPE_BASE = 0,
        ADS_SCOPE_ONELEVEL = 1,
        ADS_SCOPE_SUBTREE = 2
    } __MIDL___MIDL__intf_0000_0019;

    typedef [public]
    __MIDL___MIDL__intf_0000_0020 ADS_PREFERENCES_ENUM;

    typedef enum {
        ADSIPROP_ASYNCHRONOUS = 0,
        ADSIPROP_DEREF_ALIASES = 1,
        ADSIPROP_SIZE_LIMIT = 2,
        ADSIPROP_TIME_LIMIT = 3,
        ADSIPROP_ATTRIBTYPES_ONLY = 4,
        ADSIPROP_SEARCH_SCOPE = 5,
        ADSIPROP_TIMEOUT = 6,
        ADSIPROP_PAGESIZE = 7,
        ADSIPROP_PAGED_TIME_LIMIT = 8,
        ADSIPROP_CHASE_REFERRALS = 9,
        ADSIPROP_SORT_ON = 10,
        ADSIPROP_CACHE_RESULTS = 11
    } __MIDL___MIDL__intf_0000_0020;

    typedef [public]
    __MIDL___MIDL__intf_0000_0021 ADSI_DIALECT_ENUM;

    typedef enum {
        ADSI_DIALECT_LDAP = 0,
        ADSI_DIALECT_SQL = 1
    } __MIDL___MIDL__intf_0000_0021;

    typedef [public]
    __MIDL___MIDL__intf_0000_0022 ADS_CHASE_REFERRALS_ENUM;

    typedef enum {
        ADS_CHASE_REFERRALS_NEVER = 0,
        ADS_CHASE_REFERRALS_SUBORDINATE = 32,
        ADS_CHASE_REFERRALS_EXTERNAL = 64,
        ADS_CHASE_REFERRALS_ALWAYS = 96
    } __MIDL___MIDL__intf_0000_0022;

    typedef [public]
    __MIDL___MIDL__intf_0000_0023 ADS_SEARCHPREF_ENUM;

    typedef enum {
        ADS_SEARCHPREF_ASYNCHRONOUS = 0,
        ADS_SEARCHPREF_DEREF_ALIASES = 1,
        ADS_SEARCHPREF_SIZE_LIMIT = 2,
        ADS_SEARCHPREF_TIME_LIMIT = 3,
        ADS_SEARCHPREF_ATTRIBTYPES_ONLY = 4,
        ADS_SEARCHPREF_SEARCH_SCOPE = 5,
        ADS_SEARCHPREF_TIMEOUT = 6,
        ADS_SEARCHPREF_PAGESIZE = 7,
        ADS_SEARCHPREF_PAGED_TIME_LIMIT = 8,
        ADS_SEARCHPREF_CHASE_REFERRALS = 9,
        ADS_SEARCHPREF_SORT_ON = 10,
        ADS_SEARCHPREF_CACHE_RESULTS = 11
    } __MIDL___MIDL__intf_0000_0023;

    typedef struct tagads_searchpref_info {
                
ADS_SEARCHPREF_ENUM dwSearchPref;
                
_adsvalue vValue;
                
ADS_STATUSENUM dwStatus;
    } ads_searchpref_info;

    typedef struct tagads_search_column {
                
LPWSTR pszAttrName;
                
ADSTYPEENUM dwADsType;
                
_adsvalue* pADsValues;
                
unsigned long dwNumValues;
                
void* hReserved;
    } ads_search_column;

    typedef struct tag_ads_attr_def {
                
LPWSTR pszAttrName;
                
ADSTYPEENUM dwADsType;
                
unsigned long dwMinRange;
                
unsigned long dwMaxRange;
                
long fMultiValued;
    } _ads_attr_def;

    typedef struct tag_ads_class_def {
                
LPWSTR pszClassName;
                
unsigned long dwMandatoryAttrs;
                
LPWSTR* ppszMandatoryAttrs;
                
unsigned long optionalAttrs;
                
LPWSTR** ppszOptionalAttrs;
                
unsigned long dwNamingAttrs;
                
LPWSTR** ppszNamingAttrs;
                
unsigned long dwSuperClasses;
                
LPWSTR** ppszSuperClasses;
                
long fIsContainer;
    } _ads_class_def;

    typedef struct tag_ads_sortkey {
                
LPWSTR pszAttrType;
                
LPWSTR pszReserved;
                
char fReverseorder;
    } _ads_sortkey;

    typedef [public]
    __MIDL___MIDL__intf_0000_0024 ADS_PROPERTY_OPERATION_ENUM;

    typedef enum {
        ADS_PROPERTY_CLEAR = 1,
        ADS_PROPERTY_UPDATE = 2,
        ADS_PROPERTY_APPEND = 3,
        ADS_PROPERTY_DELETE = 4
    } __MIDL___MIDL__intf_0000_0024;

    [
      odl,
      uuid(FD8256D0-FD15-11CE-ABC4-02608C9E7553),
      dual,
      oleautomation
    ]
    interface IADs : IDispatch {
        [id(0x00000002), propget]
        HRESULT Name([out, retval] BSTR* retval);
        [id(0x00000003), propget]
        HRESULT Class([out, retval] BSTR* retval);
        [id(0x00000004), propget]
        HRESULT GUID([out, retval] BSTR* retval);
        [id(0x00000005), propget]
        HRESULT ADsPath([out, retval] BSTR* retval);
        [id(0x00000006), propget]
        HRESULT Parent([out, retval] BSTR* retval);
        [id(0x00000007), propget]
        HRESULT Schema([out, retval] BSTR* retval);
        [id(0x00000008)]
        HRESULT GetInfo();
        [id(0x00000009)]
        HRESULT SetInfo();
        [id(0x0000000a)]
        HRESULT Get(
                        [in] BSTR bstrName, 
                        [out, retval] VARIANT* pvProp);
        [id(0x0000000b)]
        HRESULT Put(
                        [in] BSTR bstrName, 
                        [in] VARIANT vProp);
        [id(0x0000000c)]
        HRESULT GetEx(
                        [in] BSTR bstrName, 
                        [out, retval] VARIANT* pvProp);
        [id(0x0000000d)]
        HRESULT PutEx(
                        [in] long lnControlCode, 
                        [in] BSTR bstrName, 
                        [in] VARIANT vProp);
        [id(0x0000000e)]
        HRESULT GetInfoEx(
                        [in] VARIANT vProperties, 
                        [in] long lnReserved);
    };

    [
      odl,
      uuid(001677D0-FD16-11CE-ABC4-02608C9E7553),
      dual,
      oleautomation
    ]
    interface IADsContainer : IDispatch {
        [id(0x00000002), propget]
        HRESULT Count([out, retval] long* retval);

        [id(0xfffffffc), propget, restricted]
        HRESULT _NewEnum([out, retval] IUnknown** retval);
        [id(0x00000003), propget]
        HRESULT Filter([out, retval] VARIANT* pVar);
        [id(0x00000003), propput]
        HRESULT Filter([in] VARIANT pVar);
        [id(0x00000004), propget]
        HRESULT Hints([out, retval] VARIANT* pvFilter);
        [id(0x00000004), propput]
        HRESULT Hints([in] VARIANT pvFilter);
        [id(0x00000005)]
        HRESULT GetObject(
                        [in] BSTR ClassName, 
                        [in] BSTR RelativeName, 
                        [out, retval] IDispatch** ppObject);
        [id(0x00000006)]
        HRESULT Create(
                        [in] BSTR ClassName, 
                        [in] BSTR RelativeName, 
                        [out, retval] IDispatch** ppObject);
        [id(0x00000007)]
        HRESULT Delete(
                        [in] BSTR bstrClassName, 
                        [in] BSTR bstrRelativeName);
        [id(0x00000008)]
        HRESULT CopyHere(
                        [in] BSTR SourceName, 
                        [in] BSTR NewName, 
                        [out, retval] IDispatch** ppObject);
        [id(0x00000009)]
        HRESULT MoveHere(
                        [in] BSTR SourceName, 
                        [in] BSTR NewName, 
                        [out, retval] IDispatch** ppObject);
    };

    [
      odl,
      uuid(72B945E0-253B-11CF-A988-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsCollection : IDispatch {
        [id(0xfffffffc), propget]
        HRESULT _NewEnum([out, retval] IUnknown** ppEnumerator);
        [id(0x00000004)]
        HRESULT Add(
                        [in] BSTR bstrName, 
                        [in] VARIANT vItem);
        [id(0x00000005)]
        HRESULT Remove([in] BSTR bstrItemToBeRemoved);
        [id(0x00000006)]
        HRESULT GetObject(
                        [in] BSTR bstrName, 
                        [out, retval] VARIANT* pvItem);
    };

    [
      odl,
      uuid(451A0030-72EC-11CF-B03B-00AA006E0975),
      dual,
      oleautomation
    ]
    interface IADsMembers : IDispatch {
        [id(0x00000002), propget]
        HRESULT Count([out, retval] long* plCount);
        [id(0xfffffffc), propget]
        HRESULT _NewEnum([out, retval] IUnknown** ppEnumerator);
        [id(0x00000003), propget]
        HRESULT Filter([out, retval] VARIANT* pvFilter);
        [id(0x00000003), propput]
        HRESULT Filter([in] VARIANT pvFilter);
    };

    [
      odl,
      uuid(C6F602B6-8F69-11D0-8528-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsPropertyList : IDispatch {
        [id(0x00000002), propget]
        HRESULT PropertyCount([out, retval] long* plCount);
        [id(0x00000003)]
        HRESULT Next([out, retval] VARIANT* pVariant);
        [id(0x00000004)]
        HRESULT Skip([in] long cElements);
        [id(0x00000005)]
        HRESULT Reset();
        [id(00000000)]
        HRESULT Item(
                        [in] VARIANT varIndex, 
                        [out, retval] VARIANT* pVariant);
        [id(0x00000006)]
        HRESULT GetPropertyItem(
                        [in] BSTR bstrName, 
                        [in] long lnADsType, 
                        [out, retval] VARIANT* pVariant);
        [id(0x00000007)]
        HRESULT PutPropertyItem([in] VARIANT varData);
        [id(0x00000008)]
        HRESULT ResetPropertyItem([in] VARIANT varEntry);
        [id(0x00000009)]
        HRESULT PurgePropertyList();
    };

    [
      odl,
      uuid(05792C8E-941F-11D0-8529-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsPropertyEntry : IDispatch {
        [id(0x00000001)]
        HRESULT Clear();
        [id(0x00000002), propget]
        HRESULT Name([out, retval] BSTR* retval);
        [id(0x00000002), propput]
        HRESULT Name([in] BSTR retval);
        [id(0x00000003), propget]
        HRESULT ADsType([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT ADsType([in] long retval);
        [id(0x00000004), propget]
        HRESULT ControlCode([out, retval] long* retval);
        [id(0x00000004), propput]
        HRESULT ControlCode([in] long retval);
        [id(0x00000005), propget]
        HRESULT Values([out, retval] VARIANT* retval);
        [id(0x00000005), propput]
        HRESULT Values([in] VARIANT retval);
    };

    [
      uuid(72D3EDC2-A4C4-11D0-8533-00C04FD8D503)
    ]
    coclass PropertyEntry {
        [default] interface IADsPropertyEntry;
        interface IDispatch;
    };

    [
      odl,
      uuid(79FA9AD0-A97C-11D0-8534-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsPropertyValue : IDispatch {
        [id(0x00000001)]
        HRESULT Clear();
        [id(0x00000002), propget]
        HRESULT ADsType([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT ADsType([in] long retval);
        [id(0x00000003), propget]
        HRESULT DNString([out, retval] BSTR* retval);
        [id(0x00000003), propput]
        HRESULT DNString([in] BSTR retval);
        [id(0x00000004), propget]
        HRESULT CaseExactString([out, retval] BSTR* retval);
        [id(0x00000004), propput]
        HRESULT CaseExactString([in] BSTR retval);
        [id(0x00000005), propget]
        HRESULT CaseIgnoreString([out, retval] BSTR* retval);
        [id(0x00000005), propput]
        HRESULT CaseIgnoreString([in] BSTR retval);
        [id(0x00000006), propget]
        HRESULT PrintableString([out, retval] BSTR* retval);
        [id(0x00000006), propput]
        HRESULT PrintableString([in] BSTR retval);
        [id(0x00000007), propget]
        HRESULT NumericString([out, retval] BSTR* retval);
        [id(0x00000007), propput]
        HRESULT NumericString([in] BSTR retval);
        [id(0x00000008), propget]
        HRESULT Boolean([out, retval] long* retval);
        [id(0x00000008), propput]
        HRESULT Boolean([in] long retval);
        [id(0x00000009), propget]
        HRESULT Integer([out, retval] long* retval);
        [id(0x00000009), propput]
        HRESULT Integer([in] long retval);
        [id(0x0000000a), propget]
        HRESULT OctetString([out, retval] VARIANT* retval);
        [id(0x0000000a), propput]
        HRESULT OctetString([in] VARIANT retval);
        [id(0x0000000b), propget]
        HRESULT SecurityDescriptor([out, retval] IDispatch** retval);
        [id(0x0000000b), propput]
        HRESULT SecurityDescriptor([in] IDispatch* retval);
        [id(0x0000000c), propget]
        HRESULT LargeInteger([out, retval] IDispatch** retval);
        [id(0x0000000c), propput]
        HRESULT LargeInteger([in] IDispatch* retval);
        [id(0x0000000d), propget]
        HRESULT UTCTime([out, retval] DATE* retval);
        [id(0x0000000d), propput]
        HRESULT UTCTime([in] DATE retval);
    };

    [
      odl,
      uuid(306E831C-5BC7-11D1-A3B8-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsPropertyValue2 : IDispatch {
        [id(0x00000001)]
        HRESULT GetObjectProperty(
                        [in, out] long* lnADsType, 
                        [out, retval] VARIANT* pvProp);
        [id(0x00000002)]
        HRESULT PutObjectProperty(
                        [in] long lnADsType, 
                        [in] VARIANT vProp);
    };

    [
      uuid(7B9E38B0-A97C-11D0-8534-00C04FD8D503)
    ]
    coclass PropertyValue {
        [default] interface IADsPropertyValue;
        interface IDispatch;
    };

    [
      odl,
      uuid(86AB4BBE-65F6-11D1-8C13-00C04FD8D503)
    ]
    interface IPrivateDispatch : IUnknown {
        HRESULT _stdcall ADSIInitializeDispatchManager([in] long dwExtensionId);
        HRESULT _stdcall ADSIGetTypeInfoCount([out] unsigned int* pctinfo);
        HRESULT _stdcall ADSIGetTypeInfo(
                        [in] unsigned int itinfo, 

                        [in] unsigned long lcid, 
                        [out] ITypeInfo** ppTInfo);
        HRESULT _stdcall ADSIGetIDsOfNames(
                        [in] GUID* riid, 
                        [in] short** rgszNames, 
                        [in] unsigned int cNames, 
                        [in] unsigned long lcid, 
                        [out] long* rgdispid);
        HRESULT _stdcall ADSIInvoke(
                        [in] long dispidMember, 
                        [in] GUID* riid, 
                        [in] unsigned long lcid, 
                        [in] unsigned short wFlags, 
                        [in] DISPPARAMS* pDispParams, 
                        [out] VARIANT* pVarResult, 
                        [out] EXCEPINFO* pExcepInfo, 
                        [out] unsigned int* puArgErr);
    };

    [
      odl,
      uuid(00020401-0000-0000-C000-000000000046)
    ]
    interface ITypeInfo : IUnknown {
        HRESULT _stdcall RemoteGetTypeAttr(
                        [out] tagTYPEATTR** ppTypeAttr, 
                        [out] DWORD* pDummy);
        HRESULT _stdcall GetTypeComp([out] ITypeComp** ppTComp);
        HRESULT _stdcall RemoteGetFuncDesc(
                        [in] unsigned int index, 
                        [out] tagFUNCDESC** ppFuncDesc, 
                        [out] DWORD* pDummy);
        HRESULT _stdcall RemoteGetVarDesc(
                        [in] unsigned int index, 
                        [out] tagVARDESC** ppVarDesc, 
                        [out] DWORD* pDummy);
        HRESULT _stdcall GetNames(
                        [in] long memid, 
                        [out] BSTR* rgBstrNames, 
                        [in] unsigned int cMaxNames, 
                        [out] unsigned int* pcNames);
        HRESULT _stdcall GetRefTypeOfImplType(
                        [in] unsigned int index, 
                        [out] unsigned long* pRefType);
        HRESULT _stdcall GetImplTypeFlags(
                        [in] unsigned int index, 
                        [out] int* pImplTypeFlags);
        HRESULT _stdcall GetIDsOfNames(
                        [in] LPWSTR* rgszNames, 
                        [in] unsigned int cNames, 
                        [out] long* pMemId);
        HRESULT _stdcall RemoteInvoke(
                        [in] IUnknown* pIUnk, 
                        [in] long memid, 
                        [in] unsigned long dwFlags, 
                        [in] DISPPARAMS* pDispParams, 
                        [out] VARIANT* rgVtRef, 
                        [in] unsigned int cVtRef, 
                        [out] VARIANT* pVarResult, 
                        [out] EXCEPINFO* pExcepInfo, 
                        [out] unsigned int* pArgErr);
        HRESULT _stdcall RemoteGetDocumentation(
                        [in] long memid, 
                        [in] unsigned long refPtrFlags, 
                        [out] BSTR* pBstrName, 
                        [out] BSTR* pBstrDocString, 
                        [out] unsigned long* pdwHelpContext, 
                        [out] BSTR* pBstrHelpFile);
        HRESULT _stdcall RemoteGetDllEntry(
                        [in] long memid, 
                        [in] tagINVOKEKIND invkind, 
                        [in] unsigned long refPtrFlags, 
                        [out] BSTR* pBstrDllName, 
                        [out] BSTR* pBstrName, 
                        [out] unsigned short* pwOrdinal);
        HRESULT _stdcall GetRefTypeInfo(
                        [in] unsigned long hreftype, 
                        [out] ITypeInfo** ppTInfo);
        HRESULT _stdcall LocalAddressOfMember();
        HRESULT _stdcall RemoteCreateInstance(
                        [in] _GUID* riid, 
                        [out] IUnknown** ppvObj);
        HRESULT _stdcall GetMops(
                        [in] long memid, 
                        [out] BSTR* pBstrMops);
        HRESULT _stdcall GetContainingTypeLib(
                        [out] ITypeLib** ppTLib, 
                        [out] unsigned int* pIndex);
        HRESULT _stdcall LocalReleaseTypeAttr();
        HRESULT _stdcall LocalReleaseFuncDesc();
        HRESULT _stdcall LocalReleaseVarDesc();
    };

    typedef struct tagtagTYPEATTR {
                
_GUID GUID;
                
unsigned long lcid;
                
unsigned long dwReserved;
                
long memidConstructor;
                
long memidDestructor;
                
LPWSTR lpstrSchema;
                
unsigned long cbSizeInstance;
                
tagTYPEKIND typekind;
                
unsigned short cFuncs;
                
unsigned short cVars;
                
unsigned short cImplTypes;
                
unsigned short cbSizeVft;
                
unsigned short cbAlignment;
                
unsigned short wTypeFlags;
                
unsigned short wMajorVerNum;
                
unsigned short wMinorVerNum;
                
tagTYPEDESC tdescAlias;
                
tagIDLDESC idldescType;
    } tagTYPEATTR;

    typedef struct tag_GUID {
                
unsigned long Data1;
                
unsigned short Data2;
                
unsigned short Data3;
                
unsigned char Data4[8];
    } _GUID;

    typedef enum {
        TKIND_ENUM = 0,
        TKIND_RECORD = 1,
        TKIND_MODULE = 2,
        TKIND_INTERFACE = 3,
        TKIND_DISPATCH = 4,
        TKIND_COCLASS = 5,
        TKIND_ALIAS = 6,
        TKIND_UNION = 7,
        TKIND_MAX = 8
    } tagTYPEKIND;

    typedef struct tagtagTYPEDESC {
                
__MIDL_IOleAutomationTypes_0005 __MIDL_0013;
                
unsigned short vt;
    } tagTYPEDESC;

    typedef union tag__MIDL_IOleAutomationTypes_0005 {
                
tagTYPEDESC* lptdesc;
                
tagARRAYDESC* lpadesc;
                
unsigned long hreftype;
    } __MIDL_IOleAutomationTypes_0005;

    typedef struct tagtagARRAYDESC {
                
tagTYPEDESC tdescElem;
                
unsigned short cDims;
                
tagSAFEARRAYBOUND* rgbounds;
    } tagARRAYDESC;

    typedef struct tagtagSAFEARRAYBOUND {
                
unsigned long cElements;
                
long lLbound;
    } tagSAFEARRAYBOUND;

    typedef struct tagtagIDLDESC {
                
unsigned long dwReserved;
                
unsigned short wIDLFlags;
    } tagIDLDESC;

    typedef [public]
    unsigned long DWORD;

    [
      odl,
      uuid(00020403-0000-0000-C000-000000000046)
    ]
    interface ITypeComp : IUnknown {
        HRESULT _stdcall RemoteBind(
                        [in] LPWSTR szName, 
                        [in] unsigned long lHashVal, 
                        [in] unsigned short wFlags, 
                        [out] ITypeInfo** ppTInfo, 
                        [out] tagDESCKIND* pDescKind, 
                        [out] tagFUNCDESC** ppFuncDesc, 
                        [out] tagVARDESC** ppVarDesc, 
                        [out] ITypeComp** ppTypeComp, 
                        [out] DWORD* pDummy);
        HRESULT _stdcall RemoteBindType(
                        [in] LPWSTR szName, 
                        [in] unsigned long lHashVal, 
                        [out] ITypeInfo** ppTInfo);
    };

    typedef enum {
        DESCKIND_NONE = 0,
        DESCKIND_FUNCDESC = 1,
        DESCKIND_VARDESC = 2,
        DESCKIND_TYPECOMP = 3,
        DESCKIND_IMPLICITAPPOBJ = 4,
        DESCKIND_MAX = 5
    } tagDESCKIND;

    typedef struct tagtagFUNCDESC {
                
long memid;
                
SCODE* lprgscode;
                
tagELEMDESC* lprgelemdescParam;
                
tagFUNCKIND funckind;
                
tagINVOKEKIND invkind;
                
tagCALLCONV callconv;
                
short cParams;
                
short cParamsOpt;
                
short oVft;
                
short cScodes;
                
tagELEMDESC elemdescFunc;
                
unsigned short wFuncFlags;
    } tagFUNCDESC;

    typedef struct tagtagELEMDESC {
                
tagTYPEDESC tdesc;
                
tagPARAMDESC paramdesc;
    } tagELEMDESC;

    typedef struct tagtagPARAMDESC {
                
tagPARAMDESCEX* pparamdescex;
                
unsigned short wParamFlags;
    } tagPARAMDESC;

    typedef struct tagtagPARAMDESCEX {
                
unsigned long cBytes;
                
VARIANT varDefaultValue;
    } tagPARAMDESCEX;

    typedef enum {
        FUNC_VIRTUAL = 0,
        FUNC_PUREVIRTUAL = 1,
        FUNC_NONVIRTUAL = 2,
        FUNC_STATIC = 3,
        FUNC_DISPATCH = 4
    } tagFUNCKIND;

    typedef enum {
        INVOKE_FUNC = 1,
        INVOKE_PROPERTYGET = 2,
        INVOKE_PROPERTYPUT = 4,
        INVOKE_PROPERTYPUTREF = 8
    } tagINVOKEKIND;

    typedef enum {
        CC_CDECL = 1,
        CC_MSCPASCAL = 2,
        CC_PASCAL = 2,
        CC_MACPASCAL = 3,
        CC_STDCALL = 4,
        CC_RESERVED = 5,
        CC_SYSCALL = 6,
        CC_MPWCDECL = 7,
        CC_MPWPASCAL = 8,
        CC_MAX = 9
    } tagCALLCONV;

    typedef struct tagtagVARDESC {
                
long memid;
                
LPWSTR lpstrSchema;
                
__MIDL_IOleAutomationTypes_0006 __MIDL_0014;
                
tagELEMDESC elemdescVar;
                
unsigned short wVarFlags;
                
tagVARKIND varkind;
    } tagVARDESC;

    typedef union tag__MIDL_IOleAutomationTypes_0006 {
                
unsigned long oInst;
                
VARIANT* lpvarValue;
    } __MIDL_IOleAutomationTypes_0006;

    typedef enum {
        VAR_PERINSTANCE = 0,
        VAR_STATIC = 1,
        VAR_CONST = 2,
        VAR_DISPATCH = 3
    } tagVARKIND;

    [
      odl,
      uuid(00020402-0000-0000-C000-000000000046)
    ]
    interface ITypeLib : IUnknown {
        HRESULT _stdcall RemoteGetTypeInfoCount([out] unsigned int* pctinfo);
        HRESULT _stdcall GetTypeInfo(
                        [in] unsigned int index, 
                        [out] ITypeInfo** ppTInfo);
        HRESULT _stdcall GetTypeInfoType(
                        [in] unsigned int index, 
                        [out] tagTYPEKIND* pTKind);
        HRESULT _stdcall GetTypeInfoOfGuid(
                        [in] GUID* GUID, 
                        [out] ITypeInfo** ppTInfo);
        HRESULT _stdcall RemoteGetLibAttr(
                        [out] tagTLIBATTR** ppTLibAttr, 
                        [out] DWORD* pDummy);
        HRESULT _stdcall GetTypeComp([out] ITypeComp** ppTComp);
        HRESULT _stdcall RemoteGetDocumentation(
                        [in] int index, 
                        [in] unsigned long refPtrFlags, 
                        [out] BSTR* pBstrName, 
                        [out] BSTR* pBstrDocString, 
                        [out] unsigned long* pdwHelpContext, 
                        [out] BSTR* pBstrHelpFile);
        HRESULT _stdcall RemoteIsName(
                        [in] LPWSTR szNameBuf, 
                        [in] unsigned long lHashVal, 
                        [out] long* pfName, 
                        [out] BSTR* pBstrLibName);
        HRESULT _stdcall RemoteFindName(
                        [in] LPWSTR szNameBuf, 
                        [in] unsigned long lHashVal, 
                        [out] ITypeInfo** ppTInfo, 
                        [out] long* rgMemId, 
                        [in, out] unsigned short* pcFound, 
                        [out] BSTR* pBstrLibName);
        HRESULT _stdcall LocalReleaseTLibAttr();
    };

    typedef struct tagtagTLIBATTR {
                
GUID GUID;
                
unsigned long lcid;
                
tagSYSKIND syskind;
                
unsigned short wMajorVerNum;
                
unsigned short wMinorVerNum;
                
unsigned short wLibFlags;
    } tagTLIBATTR;

    typedef enum {
        SYS_WIN16 = 0,
        SYS_WIN32 = 1,
        SYS_MAC = 2
    } tagSYSKIND;

    [
      odl,
      uuid(89126BAB-6EAD-11D1-8C18-00C04FD8D503)
    ]
    interface IPrivateUnknown : IUnknown {
        HRESULT _stdcall ADSIInitializeObject(
                        [in] BSTR lpszUserName, 
                        [in] BSTR lpszPassword, 
                        [in] long lnReserved);
        HRESULT _stdcall ADSIReleaseObject();
    };

    [
      odl,
      uuid(3D35553C-D2B0-11D1-B17B-0000F87593A0)
    ]
    interface IADsExtension : IUnknown {
        HRESULT _stdcall Operate(
                        [in] unsigned long dwCode, 
                        [in] VARIANT varData1, 
                        [in] VARIANT varData2, 
                        [in] VARIANT varData3);
        HRESULT _stdcall PrivateGetIDsOfNames(
                        [in] GUID* riid, 
                        [in] short** rgszNames, 
                        [in] unsigned int cNames, 
                        [in] unsigned long lcid, 
                        [out] long* rgdispid);
        HRESULT _stdcall PrivateInvoke(
                        [in] long dispidMember, 
                        [in] GUID* riid, 
                        [in] unsigned long lcid, 
                        [in] unsigned short wFlags, 
                        [in] DISPPARAMS* pDispParams, 
                        [out] VARIANT* pVarResult, 
                        [out] EXCEPINFO* pExcepInfo, 
                        [out] unsigned int* puArgErr);
    };

    [
      odl,
      uuid(B2BD0902-8878-11D1-8C21-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsDeleteOps : IDispatch {
        [id(0x00000002)]
        HRESULT DeleteObject([in] long lnFlags);
    };

    [
      odl,
      uuid(28B96BA0-B330-11CF-A9AD-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsNamespaces : IADs {
        [id(0x00000001), propget]
        HRESULT DefaultContainer([out, retval] BSTR* retval);
        [id(0x00000001), propput]
        HRESULT DefaultContainer([in] BSTR retval);
    };

    [
      odl,
      uuid(C8F93DD0-4AE0-11CF-9E73-00AA004A5691),
      dual,
      oleautomation
    ]
    interface IADsClass : IADs {
        [id(0x0000000f), propget]
        HRESULT PrimaryInterface([out, retval] BSTR* retval);
        [id(0x00000010), propget]
        HRESULT CLSID([out, retval] BSTR* retval);
        [id(0x00000010), propput]
        HRESULT CLSID([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT OID([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT OID([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT Abstract([out, retval] VARIANT_BOOL* retval);
        [id(0x00000012), propput]
        HRESULT Abstract([in] VARIANT_BOOL retval);
        [id(0x0000001a), propget]
        HRESULT Auxiliary([out, retval] VARIANT_BOOL* retval);
        [id(0x0000001a), propput]
        HRESULT Auxiliary([in] VARIANT_BOOL retval);
        [id(0x00000013), propget]
        HRESULT MandatoryProperties([out, retval] VARIANT* retval);
        [id(0x00000013), propput]
        HRESULT MandatoryProperties([in] VARIANT retval);
        [id(0x0000001d), propget]
        HRESULT OptionalProperties([out, retval] VARIANT* retval);
        [id(0x0000001d), propput]
        HRESULT OptionalProperties([in] VARIANT retval);
        [id(0x0000001e), propget]
        HRESULT NamingProperties([out, retval] VARIANT* retval);
        [id(0x0000001e), propput]
        HRESULT NamingProperties([in] VARIANT retval);
        [id(0x00000014), propget]
        HRESULT DerivedFrom([out, retval] VARIANT* retval);
        [id(0x00000014), propput]
        HRESULT DerivedFrom([in] VARIANT retval);
        [id(0x0000001b), propget]
        HRESULT AuxDerivedFrom([out, retval] VARIANT* retval);
        [id(0x0000001b), propput]
        HRESULT AuxDerivedFrom([in] VARIANT retval);
        [id(0x0000001c), propget]
        HRESULT PossibleSuperiors([out, retval] VARIANT* retval);
        [id(0x0000001c), propput]
        HRESULT PossibleSuperiors([in] VARIANT retval);
        [id(0x00000015), propget]
        HRESULT Containment([out, retval] VARIANT* retval);
        [id(0x00000015), propput]
        HRESULT Containment([in] VARIANT retval);
        [id(0x00000016), propget]
        HRESULT Container([out, retval] VARIANT_BOOL* retval);
        [id(0x00000016), propput]
        HRESULT Container([in] VARIANT_BOOL retval);
        [id(0x00000017), propget]
        HRESULT HelpFileName([out, retval] BSTR* retval);
        [id(0x00000017), propput]
        HRESULT HelpFileName([in] BSTR retval);
        [id(0x00000018), propget]
        HRESULT HelpFileContext([out, retval] long* retval);
        [id(0x00000018), propput]
        HRESULT HelpFileContext([in] long retval);
        [id(0x00000019)]
        HRESULT Qualifiers([out, retval] IADsCollection** ppQualifiers);
    };

    [
      odl,
      uuid(C8F93DD3-4AE0-11CF-9E73-00AA004A5691),
      dual,
      oleautomation
    ]
    interface IADsProperty : IADs {
        [id(0x00000011), propget]
        HRESULT OID([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT OID([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT Syntax([out, retval] BSTR* retval);
        [id(0x00000012), propput]
        HRESULT Syntax([in] BSTR retval);
        [id(0x00000013), propget]
        HRESULT MaxRange([out, retval] long* retval);
        [id(0x00000013), propput]
        HRESULT MaxRange([in] long retval);
        [id(0x00000014), propget]
        HRESULT MinRange([out, retval] long* retval);
        [id(0x00000014), propput]
        HRESULT MinRange([in] long retval);
        [id(0x00000015), propget]
        HRESULT MultiValued([out, retval] VARIANT_BOOL* retval);
        [id(0x00000015), propput]
        HRESULT MultiValued([in] VARIANT_BOOL retval);
        [id(0x00000016)]
        HRESULT Qualifiers([out, retval] IADsCollection** ppQualifiers);
    };

    [
      odl,
      uuid(C8F93DD2-4AE0-11CF-9E73-00AA004A5691),
      dual,
      oleautomation
    ]
    interface IADsSyntax : IADs {
        [id(0x0000000f), propget]
        HRESULT OleAutoDataType([out, retval] long* retval);
        [id(0x0000000f), propput]
        HRESULT OleAutoDataType([in] long retval);
    };

    typedef [public]
    __MIDL___MIDL__intf_0087_0001 ADS_SYSTEMFLAG_ENUM;

    typedef enum {
        ADS_SYSTEMFLAG_DISALLOW_DELETE = 0x80000000,
        ADS_SYSTEMFLAG_CONFIG_ALLOW_RENAME = 0x40000000,
        ADS_SYSTEMFLAG_CONFIG_ALLOW_MOVE = 0x20000000,
        ADS_SYSTEMFLAG_CONFIG_ALLOW_LIMITED_MOVE = 0x10000000,
        ADS_SYSTEMFLAG_DOMAIN_DISALLOW_RENAME = 0x08000000,
        ADS_SYSTEMFLAG_DOMAIN_DISALLOW_MOVE = 0x04000000,
        ADS_SYSTEMFLAG_CR_NTDS_NC = 1,
        ADS_SYSTEMFLAG_CR_NTDS_DOMAIN = 2,
        ADS_SYSTEMFLAG_ATTR_NOT_REPLICATED = 1,
        ADS_SYSTEMFLAG_ATTR_IS_CONSTRUCTED = 4
    } __MIDL___MIDL__intf_0087_0001;

    [
      odl,
      uuid(A05E03A2-EFFE-11CF-8ABC-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsLocality : IADs {
        [id(0x0000000f), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x0000000f), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000010), propget]
        HRESULT LocalityName([out, retval] BSTR* retval);
        [id(0x00000010), propput]
        HRESULT LocalityName([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT PostalAddress([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT PostalAddress([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT SeeAlso([out, retval] VARIANT* retval);
        [id(0x00000012), propput]
        HRESULT SeeAlso([in] VARIANT retval);
    };

    [
      odl,
      uuid(A1CD2DC6-EFFE-11CF-8ABC-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsO : IADs {
        [id(0x0000000f), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x0000000f), propput]

        HRESULT Description([in] BSTR retval);
        [id(0x00000010), propget]
        HRESULT LocalityName([out, retval] BSTR* retval);
        [id(0x00000010), propput]
        HRESULT LocalityName([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT PostalAddress([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT PostalAddress([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT TelephoneNumber([out, retval] BSTR* retval);
        [id(0x00000012), propput]
        HRESULT TelephoneNumber([in] BSTR retval);
        [id(0x00000013), propget]
        HRESULT FaxNumber([out, retval] BSTR* retval);
        [id(0x00000013), propput]
        HRESULT FaxNumber([in] BSTR retval);
        [id(0x00000014), propget]
        HRESULT SeeAlso([out, retval] VARIANT* retval);
        [id(0x00000014), propput]
        HRESULT SeeAlso([in] VARIANT retval);
    };

    [
      odl,
      uuid(A2F733B8-EFFE-11CF-8ABC-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsOU : IADs {
        [id(0x0000000f), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x0000000f), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000010), propget]
        HRESULT LocalityName([out, retval] BSTR* retval);
        [id(0x00000010), propput]
        HRESULT LocalityName([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT PostalAddress([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT PostalAddress([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT TelephoneNumber([out, retval] BSTR* retval);
        [id(0x00000012), propput]
        HRESULT TelephoneNumber([in] BSTR retval);
        [id(0x00000013), propget]
        HRESULT FaxNumber([out, retval] BSTR* retval);
        [id(0x00000013), propput]
        HRESULT FaxNumber([in] BSTR retval);
        [id(0x00000014), propget]
        HRESULT SeeAlso([out, retval] VARIANT* retval);
        [id(0x00000014), propput]
        HRESULT SeeAlso([in] VARIANT retval);
        [id(0x00000015), propget]
        HRESULT BusinessCategory([out, retval] BSTR* retval);
        [id(0x00000015), propput]
        HRESULT BusinessCategory([in] BSTR retval);
    };

    [
      odl,
      uuid(00E4C220-FD16-11CE-ABC4-02608C9E7553),
      dual,
      oleautomation
    ]
    interface IADsDomain : IADs {
        [id(0x0000000f), propget]
        HRESULT IsWorkgroup([out, retval] VARIANT_BOOL* retval);
        [id(0x00000010), propget]
        HRESULT MinPasswordLength([out, retval] long* retval);
        [id(0x00000010), propput]
        HRESULT MinPasswordLength([in] long retval);
        [id(0x00000011), propget]
        HRESULT MinPasswordAge([out, retval] long* retval);
        [id(0x00000011), propput]
        HRESULT MinPasswordAge([in] long retval);
        [id(0x00000012), propget]
        HRESULT MaxPasswordAge([out, retval] long* retval);
        [id(0x00000012), propput]
        HRESULT MaxPasswordAge([in] long retval);
        [id(0x00000013), propget]
        HRESULT MaxBadPasswordsAllowed([out, retval] long* retval);
        [id(0x00000013), propput]
        HRESULT MaxBadPasswordsAllowed([in] long retval);
        [id(0x00000014), propget]
        HRESULT PasswordHistoryLength([out, retval] long* retval);
        [id(0x00000014), propput]
        HRESULT PasswordHistoryLength([in] long retval);
        [id(0x00000015), propget]
        HRESULT PasswordAttributes([out, retval] long* retval);
        [id(0x00000015), propput]
        HRESULT PasswordAttributes([in] long retval);
        [id(0x00000016), propget]
        HRESULT AutoUnlockInterval([out, retval] long* retval);
        [id(0x00000016), propput]
        HRESULT AutoUnlockInterval([in] long retval);
        [id(0x00000017), propget]
        HRESULT LockoutObservationInterval([out, retval] long* retval);
        [id(0x00000017), propput]
        HRESULT LockoutObservationInterval([in] long retval);
    };

    [
      odl,
      uuid(EFE3CC70-1D9F-11CF-B1F3-02608C9E7553),
      dual,
      oleautomation
    ]
    interface IADsComputer : IADs {
        [id(0x00000010), propget]
        HRESULT ComputerID([out, retval] BSTR* retval);
        [id(0x00000012), propget]
        HRESULT Site([out, retval] BSTR* retval);
        [id(0x00000013), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x00000013), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000014), propget]
        HRESULT Location([out, retval] BSTR* retval);
        [id(0x00000014), propput]
        HRESULT Location([in] BSTR retval);
        [id(0x00000015), propget]
        HRESULT PrimaryUser([out, retval] BSTR* retval);
        [id(0x00000015), propput]
        HRESULT PrimaryUser([in] BSTR retval);
        [id(0x00000016), propget]
        HRESULT Owner([out, retval] BSTR* retval);
        [id(0x00000016), propput]
        HRESULT Owner([in] BSTR retval);
        [id(0x00000017), propget]
        HRESULT Division([out, retval] BSTR* retval);
        [id(0x00000017), propput]
        HRESULT Division([in] BSTR retval);
        [id(0x00000018), propget]
        HRESULT Department([out, retval] BSTR* retval);
        [id(0x00000018), propput]
        HRESULT Department([in] BSTR retval);
        [id(0x00000019), propget]
        HRESULT Role([out, retval] BSTR* retval);
        [id(0x00000019), propput]
        HRESULT Role([in] BSTR retval);
        [id(0x0000001a), propget]
        HRESULT OperatingSystem([out, retval] BSTR* retval);
        [id(0x0000001a), propput]
        HRESULT OperatingSystem([in] BSTR retval);
        [id(0x0000001b), propget]
        HRESULT OperatingSystemVersion([out, retval] BSTR* retval);
        [id(0x0000001b), propput]
        HRESULT OperatingSystemVersion([in] BSTR retval);
        [id(0x0000001c), propget]
        HRESULT Model([out, retval] BSTR* retval);
        [id(0x0000001c), propput]
        HRESULT Model([in] BSTR retval);
        [id(0x0000001d), propget]
        HRESULT Processor([out, retval] BSTR* retval);
        [id(0x0000001d), propput]
        HRESULT Processor([in] BSTR retval);
        [id(0x0000001e), propget]
        HRESULT ProcessorCount([out, retval] BSTR* retval);
        [id(0x0000001e), propput]
        HRESULT ProcessorCount([in] BSTR retval);
        [id(0x0000001f), propget]
        HRESULT MemorySize([out, retval] BSTR* retval);
        [id(0x0000001f), propput]
        HRESULT MemorySize([in] BSTR retval);
        [id(0x00000020), propget]
        HRESULT StorageCapacity([out, retval] BSTR* retval);
        [id(0x00000020), propput]
        HRESULT StorageCapacity([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT NetAddresses([out, retval] VARIANT* retval);
        [id(0x00000011), propput]
        HRESULT NetAddresses([in] VARIANT retval);
    };

    [
      odl,
      uuid(EF497680-1D9F-11CF-B1F3-02608C9E7553),
      dual,
      oleautomation
    ]
    interface IADsComputerOperations : IADs {
        [id(0x00000021)]
        HRESULT Status([out, retval] IDispatch** ppObject);
        [id(0x00000022)]
        HRESULT Shutdown([in] VARIANT_BOOL bReboot);
    };

    typedef [public]
    __MIDL___MIDL__intf_0093_0001 ADS_GROUP_TYPE_ENUM;

    typedef enum {
        ADS_GROUP_TYPE_GLOBAL_GROUP = 2,
        ADS_GROUP_TYPE_DOMAIN_LOCAL_GROUP = 4,
        ADS_GROUP_TYPE_LOCAL_GROUP = 4,
        ADS_GROUP_TYPE_UNIVERSAL_GROUP = 8,
        ADS_GROUP_TYPE_SECURITY_ENABLED = 0x80000000
    } __MIDL___MIDL__intf_0093_0001;

    [
      odl,
      uuid(27636B00-410F-11CF-B1FF-02608C9E7553),
      dual,
      oleautomation
    ]
    interface IADsGroup : IADs {
        [id(0x0000000f), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x0000000f), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000010)]
        HRESULT Members([out, retval] IADsMembers** ppMembers);
        [id(0x00000011)]
        HRESULT IsMember(
                        [in] BSTR bstrMember, 
                        [out, retval] VARIANT_BOOL* bMember);
        [id(0x00000012)]
        HRESULT Add([in] BSTR bstrNewItem);
        [id(0x00000013)]
        HRESULT Remove([in] BSTR bstrItemToBeRemoved);
    };

    [
      odl,
      uuid(3E37E320-17E2-11CF-ABC4-02608C9E7553),
      dual,
      oleautomation
    ]
    interface IADsUser : IADs {
        [id(0x00000035), propget]
        HRESULT BadLoginAddress([out, retval] BSTR* retval);
        [id(0x00000036), propget]
        HRESULT BadLoginCount([out, retval] long* retval);
        [id(0x00000038), propget]
        HRESULT LastLogin([out, retval] DATE* retval);
        [id(0x00000039), propget]
        HRESULT LastLogoff([out, retval] DATE* retval);
        [id(0x0000003a), propget]
        HRESULT LastFailedLogin([out, retval] DATE* retval);
        [id(0x0000003b), propget]
        HRESULT PasswordLastChanged([out, retval] DATE* retval);
        [id(0x0000000f), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x0000000f), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000013), propget]
        HRESULT Division([out, retval] BSTR* retval);
        [id(0x00000013), propput]
        HRESULT Division([in] BSTR retval);
        [id(0x0000007a), propget]
        HRESULT Department([out, retval] BSTR* retval);
        [id(0x0000007a), propput]
        HRESULT Department([in] BSTR retval);
        [id(0x00000014), propget]
        HRESULT EmployeeID([out, retval] BSTR* retval);
        [id(0x00000014), propput]
        HRESULT EmployeeID([in] BSTR retval);
        [id(0x00000017), propget]
        HRESULT FullName([out, retval] BSTR* retval);
        [id(0x00000017), propput]
        HRESULT FullName([in] BSTR retval);
        [id(0x00000016), propget]
        HRESULT FirstName([out, retval] BSTR* retval);
        [id(0x00000016), propput]
        HRESULT FirstName([in] BSTR retval);
        [id(0x00000019), propget]
        HRESULT LastName([out, retval] BSTR* retval);
        [id(0x00000019), propput]
        HRESULT LastName([in] BSTR retval);
        [id(0x0000001b), propget]
        HRESULT OtherName([out, retval] BSTR* retval);
        [id(0x0000001b), propput]
        HRESULT OtherName([in] BSTR retval);
        [id(0x00000072), propget]
        HRESULT NamePrefix([out, retval] BSTR* retval);
        [id(0x00000072), propput]
        HRESULT NamePrefix([in] BSTR retval);
        [id(0x00000073), propget]
        HRESULT NameSuffix([out, retval] BSTR* retval);
        [id(0x00000073), propput]
        HRESULT NameSuffix([in] BSTR retval);
        [id(0x00000024), propget]
        HRESULT Title([out, retval] BSTR* retval);
        [id(0x00000024), propput]
        HRESULT Title([in] BSTR retval);
        [id(0x0000001a), propget]
        HRESULT Manager([out, retval] BSTR* retval);
        [id(0x0000001a), propput]
        HRESULT Manager([in] BSTR retval);
        [id(0x00000020), propget]
        HRESULT TelephoneHome([out, retval] VARIANT* retval);
        [id(0x00000020), propput]
        HRESULT TelephoneHome([in] VARIANT retval);
        [id(0x00000021), propget]
        HRESULT TelephoneMobile([out, retval] VARIANT* retval);
        [id(0x00000021), propput]
        HRESULT TelephoneMobile([in] VARIANT retval);
        [id(0x00000022), propget]
        HRESULT TelephoneNumber([out, retval] VARIANT* retval);
        [id(0x00000022), propput]
        HRESULT TelephoneNumber([in] VARIANT retval);
        [id(0x00000011), propget]
        HRESULT TelephonePager([out, retval] VARIANT* retval);
        [id(0x00000011), propput]
        HRESULT TelephonePager([in] VARIANT retval);
        [id(0x00000010), propget]
        HRESULT FaxNumber([out, retval] VARIANT* retval);
        [id(0x00000010), propput]
        HRESULT FaxNumber([in] VARIANT retval);
        [id(0x0000001c), propget]
        HRESULT OfficeLocations([out, retval] VARIANT* retval);
        [id(0x0000001c), propput]
        HRESULT OfficeLocations([in] VARIANT retval);
        [id(0x0000001e), propget]
        HRESULT PostalAddresses([out, retval] VARIANT* retval);
        [id(0x0000001e), propput]
        HRESULT PostalAddresses([in] VARIANT retval);
        [id(0x0000001f), propget]
        HRESULT PostalCodes([out, retval] VARIANT* retval);
        [id(0x0000001f), propput]
        HRESULT PostalCodes([in] VARIANT retval);
        [id(0x00000075), propget]
        HRESULT SeeAlso([out, retval] VARIANT* retval);
        [id(0x00000075), propput]
        HRESULT SeeAlso([in] VARIANT retval);
        [id(0x00000025), propget]
        HRESULT AccountDisabled([out, retval] VARIANT_BOOL* retval);
        [id(0x00000025), propput]
        HRESULT AccountDisabled([in] VARIANT_BOOL retval);
        [id(0x00000026), propget]
        HRESULT AccountExpirationDate([out, retval] DATE* retval);
        [id(0x00000026), propput]
        HRESULT AccountExpirationDate([in] DATE retval);
        [id(0x00000029), propget]
        HRESULT GraceLoginsAllowed([out, retval] long* retval);
        [id(0x00000029), propput]
        HRESULT GraceLoginsAllowed([in] long retval);
        [id(0x0000002a), propget]
        HRESULT GraceLoginsRemaining([out, retval] long* retval);
        [id(0x0000002a), propput]
        HRESULT GraceLoginsRemaining([in] long retval);
        [id(0x0000002b), propget]
        HRESULT IsAccountLocked([out, retval] VARIANT_BOOL* retval);
        [id(0x0000002b), propput]
        HRESULT IsAccountLocked([in] VARIANT_BOOL retval);
        [id(0x0000002d), propget]
        HRESULT LoginHours([out, retval] VARIANT* retval);
        [id(0x0000002d), propput]
        HRESULT LoginHours([in] VARIANT retval);
        [id(0x0000002e), propget]
        HRESULT LoginWorkstations([out, retval] VARIANT* retval);
        [id(0x0000002e), propput]
        HRESULT LoginWorkstations([in] VARIANT retval);
        [id(0x0000002f), propget]
        HRESULT MaxLogins([out, retval] long* retval);
        [id(0x0000002f), propput]
        HRESULT MaxLogins([in] long retval);
        [id(0x00000030), propget]
        HRESULT MaxStorage([out, retval] long* retval);
        [id(0x00000030), propput]
        HRESULT MaxStorage([in] long retval);
        [id(0x00000031), propget]
        HRESULT PasswordExpirationDate([out, retval] DATE* retval);
        [id(0x00000031), propput]
        HRESULT PasswordExpirationDate([in] DATE retval);
        [id(0x00000032), propget]
        HRESULT PasswordMinimumLength([out, retval] long* retval);
        [id(0x00000032), propput]
        HRESULT PasswordMinimumLength([in] long retval);
        [id(0x00000033), propget]
        HRESULT PasswordRequired([out, retval] VARIANT_BOOL* retval);
        [id(0x00000033), propput]
        HRESULT PasswordRequired([in] VARIANT_BOOL retval);
        [id(0x00000034), propget]
        HRESULT RequireUniquePassword([out, retval] VARIANT_BOOL* retval);
        [id(0x00000034), propput]
        HRESULT RequireUniquePassword([in] VARIANT_BOOL retval);
        [id(0x0000003c), propget]
        HRESULT EmailAddress([out, retval] BSTR* retval);
        [id(0x0000003c), propput]
        HRESULT EmailAddress([in] BSTR retval);
        [id(0x0000003d), propget]
        HRESULT HomeDirectory([out, retval] BSTR* retval);
        [id(0x0000003d), propput]
        HRESULT HomeDirectory([in] BSTR retval);
        [id(0x0000003e), propget]
        HRESULT Languages([out, retval] VARIANT* retval);
        [id(0x0000003e), propput]
        HRESULT Languages([in] VARIANT retval);
        [id(0x0000003f), propget]
        HRESULT Profile([out, retval] BSTR* retval);
        [id(0x0000003f), propput]
        HRESULT Profile([in] BSTR retval);
        [id(0x00000040), propget]
        HRESULT LoginScript([out, retval] BSTR* retval);
        [id(0x00000040), propput]
        HRESULT LoginScript([in] BSTR retval);
        [id(0x00000041), propget]
        HRESULT Picture([out, retval] VARIANT* retval);
        [id(0x00000041), propput]
        HRESULT Picture([in] VARIANT retval);
        [id(0x00000078), propget]
        HRESULT HomePage([out, retval] BSTR* retval);
        [id(0x00000078), propput]
        HRESULT HomePage([in] BSTR retval);
        [id(0x00000042)]
        HRESULT Groups([out, retval] IADsMembers** ppGroups);
        [id(0x00000043)]
        HRESULT SetPassword([in] BSTR NewPassword);
        [id(0x00000044)]
        HRESULT ChangePassword(
                        [in] BSTR bstrOldPassword, 
                        [in] BSTR bstrNewPassword);
    };

    typedef enum {
        ADS_UF_SCRIPT = 1,
        ADS_UF_ACCOUNTDISABLE = 2,
        ADS_UF_HOMEDIR_REQUIRED = 8,
        ADS_UF_LOCKOUT = 16,
        ADS_UF_PASSWD_NOTREQD = 32,
        ADS_UF_PASSWD_CANT_CHANGE = 64,
        ADS_UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED = 128,
        ADS_UF_TEMP_DUPLICATE_ACCOUNT = 256,
        ADS_UF_NORMAL_ACCOUNT = 512,
        ADS_UF_INTERDOMAIN_TRUST_ACCOUNT = 2048,
        ADS_UF_WORKSTATION_TRUST_ACCOUNT = 4096,
        ADS_UF_SERVER_TRUST_ACCOUNT = 8192,
        ADS_UF_DONT_EXPIRE_PASSWD = 0x00010000,
        ADS_UF_MNS_LOGON_ACCOUNT = 0x00020000,
        ADS_UF_SMARTCARD_REQUIRED = 0x00040000,
        ADS_UF_TRUSTED_FOR_DELEGATION = 0x00080000,
        ADS_UF_NOT_DELEGATED = 0x00100000
    } ADS_USER_FLAG;

    [
      odl,
      uuid(B15160D0-1226-11CF-A985-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsPrintQueue : IADs {
        [id(0x0000000f), propget]
        HRESULT PrinterPath([out, retval] BSTR* retval);
        [id(0x0000000f), propput]
        HRESULT PrinterPath([in] BSTR retval);
        [id(0x00000010), propget]
        HRESULT Model([out, retval] BSTR* retval);
        [id(0x00000010), propput]
        HRESULT Model([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT Datatype([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT Datatype([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT PrintProcessor([out, retval] BSTR* retval);
        [id(0x00000012), propput]
        HRESULT PrintProcessor([in] BSTR retval);
        [id(0x00000013), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x00000013), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000014), propget]
        HRESULT Location([out, retval] BSTR* retval);
        [id(0x00000014), propput]
        HRESULT Location([in] BSTR retval);
        [id(0x00000015), propget]
        HRESULT StartTime([out, retval] DATE* retval);
        [id(0x00000015), propput]
        HRESULT StartTime([in] DATE retval);
        [id(0x00000016), propget]
        HRESULT UntilTime([out, retval] DATE* retval);
        [id(0x00000016), propput]
        HRESULT UntilTime([in] DATE retval);
        [id(0x00000017), propget]
        HRESULT DefaultJobPriority([out, retval] long* retval);
        [id(0x00000017), propput]
        HRESULT DefaultJobPriority([in] long retval);
        [id(0x00000018), propget]
        HRESULT Priority([out, retval] long* retval);
        [id(0x00000018), propput]
        HRESULT Priority([in] long retval);
        [id(0x00000019), propget]
        HRESULT BannerPage([out, retval] BSTR* retval);
        [id(0x00000019), propput]
        HRESULT BannerPage([in] BSTR retval);
        [id(0x0000001a), propget]
        HRESULT PrintDevices([out, retval] VARIANT* retval);
        [id(0x0000001a), propput]
        HRESULT PrintDevices([in] VARIANT retval);
        [id(0x0000001b), propget]
        HRESULT NetAddresses([out, retval] VARIANT* retval);
        [id(0x0000001b), propput]
        HRESULT NetAddresses([in] VARIANT retval);
    };

    [
      odl,
      uuid(124BE5C0-156E-11CF-A986-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsPrintQueueOperations : IADs {
        [id(0x0000001b), propget]
        HRESULT Status([out, retval] long* retval);
        [id(0x0000001c)]
        HRESULT PrintJobs([out, retval] IADsCollection** pObject);
        [id(0x0000001d)]
        HRESULT Pause();
        [id(0x0000001e)]
        HRESULT Resume();
        [id(0x0000001f)]
        HRESULT Purge();
    };

    [
      odl,
      uuid(32FB6780-1ED0-11CF-A988-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsPrintJob : IADs {
        [id(0x0000000f), propget]
        HRESULT HostPrintQueue([out, retval] BSTR* retval);
        [id(0x00000010), propget]
        HRESULT User([out, retval] BSTR* retval);
        [id(0x00000011), propget]
        HRESULT UserPath([out, retval] BSTR* retval);
        [id(0x00000012), propget]
        HRESULT TimeSubmitted([out, retval] DATE* retval);
        [id(0x00000013), propget]
        HRESULT TotalPages([out, retval] long* retval);
        [id(0x000000ea), propget]
        HRESULT Size([out, retval] long* retval);
        [id(0x00000014), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x00000014), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000015), propget]
        HRESULT Priority([out, retval] long* retval);
        [id(0x00000015), propput]
        HRESULT Priority([in] long retval);
        [id(0x00000016), propget]
        HRESULT StartTime([out, retval] DATE* retval);
        [id(0x00000016), propput]
        HRESULT StartTime([in] DATE retval);
        [id(0x00000017), propget]
        HRESULT UntilTime([out, retval] DATE* retval);
        [id(0x00000017), propput]
        HRESULT UntilTime([in] DATE retval);
        [id(0x00000018), propget]
        HRESULT Notify([out, retval] BSTR* retval);
        [id(0x00000018), propput]
        HRESULT Notify([in] BSTR retval);
        [id(0x00000019), propget]
        HRESULT NotifyPath([out, retval] BSTR* retval);
        [id(0x00000019), propput]
        HRESULT NotifyPath([in] BSTR retval);
    };

    [
      odl,
      uuid(9A52DB30-1ECF-11CF-A988-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsPrintJobOperations : IADs {
        [id(0x0000001a), propget]
        HRESULT Status([out, retval] long* retval);
        [id(0x0000001b), propget]
        HRESULT TimeElapsed([out, retval] long* retval);
        [id(0x0000001c), propget]
        HRESULT PagesPrinted([out, retval] long* retval);
        [id(0x0000001d), propget]
        HRESULT Position([out, retval] long* retval);
        [id(0x0000001d), propput]
        HRESULT Position([in] long retval);
        [id(0x0000001e)]
        HRESULT Pause();
        [id(0x0000001f)]
        HRESULT Resume();
    };

    [
      odl,
      uuid(68AF66E0-31CA-11CF-A98A-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsService : IADs {
        [id(0x0000000f), propget]
        HRESULT HostComputer([out, retval] BSTR* retval);
        [id(0x0000000f), propput]
        HRESULT HostComputer([in] BSTR retval);
        [id(0x00000010), propget]
        HRESULT DisplayName([out, retval] BSTR* retval);
        [id(0x00000010), propput]
        HRESULT DisplayName([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT Version([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT Version([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT ServiceType([out, retval] long* retval);
        [id(0x00000012), propput]
        HRESULT ServiceType([in] long retval);
        [id(0x00000013), propget]
        HRESULT StartType([out, retval] long* retval);
        [id(0x00000013), propput]
        HRESULT StartType([in] long retval);
        [id(0x00000014), propget]
        HRESULT Path([out, retval] BSTR* retval);
        [id(0x00000014), propput]
        HRESULT Path([in] BSTR retval);
        [id(0x00000015), propget]
        HRESULT StartupParameters([out, retval] BSTR* retval);
        [id(0x00000015), propput]
        HRESULT StartupParameters([in] BSTR retval);
        [id(0x00000016), propget]
        HRESULT ErrorControl([out, retval] long* retval);
        [id(0x00000016), propput]
        HRESULT ErrorControl([in] long retval);
        [id(0x00000017), propget]
        HRESULT LoadOrderGroup([out, retval] BSTR* retval);
        [id(0x00000017), propput]
        HRESULT LoadOrderGroup([in] BSTR retval);
        [id(0x00000018), propget]
        HRESULT ServiceAccountName([out, retval] BSTR* retval);
        [id(0x00000018), propput]
        HRESULT ServiceAccountName([in] BSTR retval);
        [id(0x00000019), propget]
        HRESULT ServiceAccountPath([out, retval] BSTR* retval);
        [id(0x00000019), propput]
        HRESULT ServiceAccountPath([in] BSTR retval);
        [id(0x0000001a), propget]
        HRESULT Dependencies([out, retval] VARIANT* retval);
        [id(0x0000001a), propput]
        HRESULT Dependencies([in] VARIANT retval);
    };

    [
      odl,
      uuid(5D7B33F0-31CA-11CF-A98A-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsServiceOperations : IADs {
        [id(0x0000001b), propget]
        HRESULT Status([out, retval] long* retval);
        [id(0x0000001c)]
        HRESULT Start();
        [id(0x0000001d)]
        HRESULT Stop();
        [id(0x0000001e)]
        HRESULT Pause();
        [id(0x0000001f)]
        HRESULT Continue();
        [id(0x00000020)]
        HRESULT SetPassword([in] BSTR bstrNewPassword);
    };

    [
      odl,
      uuid(A89D1900-31CA-11CF-A98A-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsFileService : IADsService {
        [id(0x00000021), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x00000021), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000022), propget]
        HRESULT MaxUserCount([out, retval] long* retval);
        [id(0x00000022), propput]
        HRESULT MaxUserCount([in] long retval);
    };

    [
      odl,
      uuid(A02DED10-31CA-11CF-A98A-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsFileServiceOperations : IADsServiceOperations {
        [id(0x00000023)]
        HRESULT Sessions([out, retval] IADsCollection** ppSessions);
        [id(0x00000024)]
        HRESULT Resources([out, retval] IADsCollection** ppResources);
    };

    [
      odl,
      uuid(EB6DCAF0-4B83-11CF-A995-00AA006BC149),
      dual,
      oleautomation
    ]
    interface IADsFileShare : IADs {
        [id(0x0000000f), propget]
        HRESULT CurrentUserCount([out, retval] long* retval);
        [id(0x00000010), propget]
        HRESULT Description([out, retval] BSTR* retval);
        [id(0x00000010), propput]
        HRESULT Description([in] BSTR retval);
        [id(0x00000011), propget]
        HRESULT HostComputer([out, retval] BSTR* retval);
        [id(0x00000011), propput]
        HRESULT HostComputer([in] BSTR retval);
        [id(0x00000012), propget]
        HRESULT Path([out, retval] BSTR* retval);
        [id(0x00000012), propput]
        HRESULT Path([in] BSTR retval);
        [id(0x00000013), propget]
        HRESULT MaxUserCount([out, retval] long* retval);
        [id(0x00000013), propput]
        HRESULT MaxUserCount([in] long retval);
    };

    [
      odl,
      uuid(398B7DA0-4AAB-11CF-AE2C-00AA006EBFB9),
      dual,
      oleautomation
    ]
    interface IADsSession : IADs {
        [id(0x0000000f), propget]
        HRESULT User([out, retval] BSTR* retval);
        [id(0x00000010), propget]
        HRESULT UserPath([out, retval] BSTR* retval);
        [id(0x00000011), propget]
        HRESULT Computer([out, retval] BSTR* retval);
        [id(0x00000012), propget]
        HRESULT ComputerPath([out, retval] BSTR* retval);
        [id(0x00000013), propget]
        HRESULT ConnectTime([out, retval] long* retval);
        [id(0x00000014), propget]
        HRESULT IdleTime([out, retval] long* retval);
    };

    [
      odl,
      uuid(34A05B20-4AAB-11CF-AE2C-00AA006EBFB9),
      dual,
      oleautomation
    ]
    interface IADsResource : IADs {
        [id(0x0000000f), propget]
        HRESULT User([out, retval] BSTR* retval);
        [id(0x00000010), propget]
        HRESULT UserPath([out, retval] BSTR* retval);
        [id(0x00000011), propget]
        HRESULT Path([out, retval] BSTR* retval);
        [id(0x00000012), propget]
        HRESULT LockCount([out, retval] long* retval);
    };

    [
      odl,
      uuid(DDF2891E-0F9C-11D0-8AD4-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsOpenDSObject : IDispatch {
        [id(0x00000001)]
        HRESULT OpenDSObject(
                        [in] BSTR lpszDNName, 
                        [in] BSTR lpszUserName, 
                        [in] BSTR lpszPassword, 
                        [in] long lnReserved, 
                        [out, retval] IDispatch** ppOleDsObj);
    };

    [
      odl,
      uuid(E798DE2C-22E4-11D0-84FE-00C04FD8D503)
    ]
    interface IDirectoryObject : IUnknown {
        HRESULT _stdcall GetObjectInformation([out] _ads_object_info** ppObjInfo);
        HRESULT _stdcall GetObjectAttributes(
                        [in] LPWSTR* pAttributeNames, 
                        [in] unsigned long dwNumberAttributes, 
                        [out] _ads_attr_info** ppAttributeEntries, 
                        [out] unsigned long* pdwNumAttributesReturned);
        HRESULT _stdcall SetObjectAttributes(
                        [in] _ads_attr_info* pAttributeEntries, 
                        [in] unsigned long dwNumAttributes, 
                        [out] unsigned long* pdwNumAttributesModified);
        HRESULT _stdcall CreateDSObject(
                        [in] LPWSTR pszRDNName, 
                        [in] _ads_attr_info* pAttributeEntries, 
                        [in] unsigned long dwNumAttributes, 
                        [out] IDispatch** ppObject);
        HRESULT _stdcall DeleteDSObject([in] LPWSTR pszRDNName);
    };

    [
      odl,
      uuid(109BA8EC-92F0-11D0-A790-00C04FD8D5A8)
    ]
    interface IDirectorySearch : IUnknown {
        HRESULT _stdcall SetSearchPreference(
                        [in] ads_searchpref_info* pSearchPrefs, 
                        [in] unsigned long dwNumPrefs);
        HRESULT _stdcall ExecuteSearch(
                        [in] LPWSTR pszSearchFilter, 
                        [in] LPWSTR* pAttributeNames, 
                        [in] unsigned long dwNumberAttributes, 
                        [out] void** phSearchResult);
        HRESULT _stdcall AbandonSearch([in] void* phSearchResult);
        HRESULT _stdcall GetFirstRow([in] void* hSearchResult);
        HRESULT _stdcall GetNextRow([in] void* hSearchResult);
        HRESULT _stdcall GetPreviousRow([in] void* hSearchResult);
        HRESULT _stdcall GetNextColumnName(
                        [in] void* hSearchHandle, 
                        [out] LPWSTR* ppszColumnName);
        HRESULT _stdcall GetColumn(
                        [in] void* hSearchResult, 
                        [in] LPWSTR szColumnName, 
                        [out] ads_search_column* pSearchColumn);
        HRESULT _stdcall FreeColumn([in] ads_search_column* pSearchColumn);
        HRESULT _stdcall CloseSearchHandle([in] void* hSearchResult);
    };

    [
      odl,
      uuid(75DB3B9C-A4D8-11D0-A79C-00C04FD8D5A8)
    ]
    interface IDirectorySchemaMgmt : IUnknown {
        HRESULT _stdcall EnumAttributes(
                        LPWSTR* ppszAttrNames, 
                        unsigned long dwNumAttributes, 
                        _ads_attr_def** ppAttrDefinition, 
                        unsigned long* pdwNumAttributes);
        HRESULT _stdcall CreateAttributeDefinition(
                        LPWSTR pszAttributeName, 
                        _ads_attr_def* pAttributeDefinition);
        HRESULT _stdcall WriteAttributeDefinition(
                        LPWSTR pszAttributeName, 
                        _ads_attr_def* pAttributeDefinition);
        HRESULT _stdcall DeleteAttributeDefinition(LPWSTR pszAttributeName);
        HRESULT _stdcall EnumClasses(
                        LPWSTR* ppszClassNames, 
                        unsigned long dwNumClasses, 
                        _ads_class_def** ppClassDefinition, 
                        unsigned long* pdwNumClasses);
        HRESULT _stdcall WriteClassDefinition(
                        LPWSTR pszClassName, 
                        _ads_class_def* pClassDefinition);
        HRESULT _stdcall CreateClassDefinition(
                        LPWSTR pszClassName, 
                        _ads_class_def* pClassDefinition);
        HRESULT _stdcall DeleteClassDefinition(LPWSTR pszClassName);
    };

    [
      odl,
      uuid(1346CE8C-9039-11D0-8528-00C04FD8D503)
    ]
    interface IADsAggregatee : IUnknown {
        HRESULT _stdcall ConnectAsAggregatee(IUnknown* pOuterUnknown);
        HRESULT _stdcall DisconnectAsAggregatee();
        HRESULT _stdcall RelinquishInterface(GUID* riid);
        HRESULT _stdcall RestoreInterface(GUID* riid);
    };

    [
      odl,
      uuid(52DB5FB0-941F-11D0-8529-00C04FD8D503)
    ]
    interface IADsAggregator : IUnknown {
        HRESULT _stdcall ConnectAsAggregator(IUnknown* pAggregatee);
        HRESULT _stdcall DisconnectAsAggregator();
    };

    [
      odl,
      uuid(B4F3A14C-9BDD-11D0-852C-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsAccessControlEntry : IDispatch {
        [id(0x00000002), propget]
        HRESULT AccessMask([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT AccessMask([in] long retval);
        [id(0x00000003), propget]
        HRESULT AceType([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT AceType([in] long retval);
        [id(0x00000004), propget]
        HRESULT AceFlags([out, retval] long* retval);
        [id(0x00000004), propput]
        HRESULT AceFlags([in] long retval);
        [id(0x00000005), propget]
        HRESULT Flags([out, retval] long* retval);
        [id(0x00000005), propput]
        HRESULT Flags([in] long retval);
        [id(0x00000006), propget]
        HRESULT ObjectType([out, retval] BSTR* retval);
        [id(0x00000006), propput]
        HRESULT ObjectType([in] BSTR retval);
        [id(0x00000007), propget]
        HRESULT InheritedObjectType([out, retval] BSTR* retval);
        [id(0x00000007), propput]
        HRESULT InheritedObjectType([in] BSTR retval);
        [id(0x00000008), propget]
        HRESULT Trustee([out, retval] BSTR* retval);
        [id(0x00000008), propput]
        HRESULT Trustee([in] BSTR retval);
    };

    [
      uuid(B75AC000-9BDD-11D0-852C-00C04FD8D503)
    ]
    coclass AccessControlEntry {
        [default] interface IADsAccessControlEntry;
        interface IDispatch;
    };

    [
      odl,
      uuid(B7EE91CC-9BDD-11D0-852C-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsAccessControlList : IDispatch {
        [id(0x00000003), propget]
        HRESULT AclRevision([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT AclRevision([in] long retval);
        [id(0x00000004), propget]
        HRESULT AceCount([out, retval] long* retval);
        [id(0x00000004), propput]
        HRESULT AceCount([in] long retval);
        [id(0x00000005)]
        HRESULT AddAce([in] IDispatch* pAccessControlEntry);
        [id(0x00000006)]
        HRESULT RemoveAce([in] IDispatch* pAccessControlEntry);
        [id(0x00000007)]
        HRESULT CopyAccessList([out, retval] IDispatch** ppAccessControlList);
        [id(0xfffffffc), propget, restricted]
        HRESULT _NewEnum([out, retval] IUnknown** retval);
    };

    [
      uuid(B85EA052-9BDD-11D0-852C-00C04FD8D503)
    ]
    coclass AccessControlList {
        [default] interface IADsAccessControlList;
        interface IDispatch;
    };

    [
      odl,
      uuid(B8C787CA-9BDD-11D0-852C-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsSecurityDescriptor : IDispatch {
        [id(0x00000002), propget]
        HRESULT Revision([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT Revision([in] long retval);
        [id(0x00000003), propget]
        HRESULT Control([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT Control([in] long retval);
        [id(0x00000004), propget]
        HRESULT Owner([out, retval] BSTR* retval);
        [id(0x00000004), propput]
        HRESULT Owner([in] BSTR retval);
        [id(0x00000005), propget]
        HRESULT OwnerDefaulted([out, retval] VARIANT_BOOL* retval);
        [id(0x00000005), propput]
        HRESULT OwnerDefaulted([in] VARIANT_BOOL retval);
        [id(0x00000006), propget]
        HRESULT Group([out, retval] BSTR* retval);
        [id(0x00000006), propput]
        HRESULT Group([in] BSTR retval);
        [id(0x00000007), propget]
        HRESULT GroupDefaulted([out, retval] VARIANT_BOOL* retval);
        [id(0x00000007), propput]
        HRESULT GroupDefaulted([in] VARIANT_BOOL retval);
        [id(0x00000008), propget]
        HRESULT DiscretionaryAcl([out, retval] IDispatch** retval);
        [id(0x00000008), propput]
        HRESULT DiscretionaryAcl([in] IDispatch* retval);
        [id(0x00000009), propget]
        HRESULT DaclDefaulted([out, retval] VARIANT_BOOL* retval);
        [id(0x00000009), propput]
        HRESULT DaclDefaulted([in] VARIANT_BOOL retval);
        [id(0x0000000a), propget]
        HRESULT SystemAcl([out, retval] IDispatch** retval);
        [id(0x0000000a), propput]
        HRESULT SystemAcl([in] IDispatch* retval);
        [id(0x0000000b), propget]
        HRESULT SaclDefaulted([out, retval] VARIANT_BOOL* retval);
        [id(0x0000000b), propput]
        HRESULT SaclDefaulted([in] VARIANT_BOOL retval);
        [id(0x0000000c)]
        HRESULT CopySecurityDescriptor([out, retval] IDispatch** ppSecurityDescriptor);
    };

    [
      uuid(B958F73C-9BDD-11D0-852C-00C04FD8D503)
    ]
    coclass SecurityDescriptor {
        [default] interface IADsSecurityDescriptor;
        interface IDispatch;
    };

    typedef [public]
    __MIDL___MIDL__intf_0115_0001 ADS_RIGHTS_ENUM;

    typedef enum {
        ADS_RIGHT_DELETE = 0x00010000,
        ADS_RIGHT_READ_CONTROL = 0x00020000,
        ADS_RIGHT_WRITE_DAC = 0x00040000,
        ADS_RIGHT_WRITE_OWNER = 0x00080000,
        ADS_RIGHT_SYNCHRONIZE = 0x00100000,
        ADS_RIGHT_ACCESS_SYSTEM_SECURITY = 0x01000000,
        ADS_RIGHT_GENERIC_READ = 0x80000000,
        ADS_RIGHT_GENERIC_WRITE = 0x40000000,
        ADS_RIGHT_GENERIC_EXECUTE = 0x20000000,
        ADS_RIGHT_GENERIC_ALL = 0x10000000,
        ADS_RIGHT_DS_CREATE_CHILD = 1,
        ADS_RIGHT_DS_DELETE_CHILD = 2,
        ADS_RIGHT_ACTRL_DS_LIST = 4,
        ADS_RIGHT_DS_SELF = 8,
        ADS_RIGHT_DS_READ_PROP = 16,
        ADS_RIGHT_DS_WRITE_PROP = 32,
        ADS_RIGHT_DS_DELETE_TREE = 64,
        ADS_RIGHT_DS_LIST_OBJECT = 128,
        ADS_RIGHT_DS_CONTROL_ACCESS = 256
    } __MIDL___MIDL__intf_0115_0001;

    typedef [public]
    __MIDL___MIDL__intf_0115_0002 ADS_ACETYPE_ENUM;

    typedef enum {
        ADS_ACETYPE_ACCESS_ALLOWED = 0,
        ADS_ACETYPE_ACCESS_DENIED = 1,
        ADS_ACETYPE_SYSTEM_AUDIT = 2,
        ADS_ACETYPE_ACCESS_ALLOWED_OBJECT = 5,
        ADS_ACETYPE_ACCESS_DENIED_OBJECT = 6,
        ADS_ACETYPE_SYSTEM_AUDIT_OBJECT = 7
    } __MIDL___MIDL__intf_0115_0002;

    typedef [public]
    __MIDL___MIDL__intf_0115_0003 ADS_ACEFLAG_ENUM;

    typedef enum {
        ADS_ACEFLAG_INHERIT_ACE = 2,
        ADS_ACEFLAG_NO_PROPAGATE_INHERIT_ACE = 4,
        ADS_ACEFLAG_INHERIT_ONLY_ACE = 8,
        ADS_ACEFLAG_INHERITED_ACE = 16,
        ADS_ACEFLAG_VALID_INHERIT_FLAGS = 31,
        ADS_ACEFLAG_SUCCESSFUL_ACCESS = 64,
        ADS_ACEFLAG_FAILED_ACCESS = 128
    } __MIDL___MIDL__intf_0115_0003;


    typedef [public]
    __MIDL___MIDL__intf_0115_0004 ADS_FLAGTYPE_ENUM;

    typedef enum {
        ADS_FLAG_OBJECT_TYPE_PRESENT = 1,
        ADS_FLAG_INHERITED_OBJECT_TYPE_PRESENT = 2
    } __MIDL___MIDL__intf_0115_0004;

    typedef [public]
    __MIDL___MIDL__intf_0115_0005 ADS_SD_CONTROL_ENUM;

    typedef enum {
        ADS_SD_CONTROL_SE_OWNER_DEFAULTED = 1,
        ADS_SD_CONTROL_SE_GROUP_DEFAULTED = 2,
        ADS_SD_CONTROL_SE_DACL_PRESENT = 4,
        ADS_SD_CONTROL_SE_DACL_DEFAULTED = 8,
        ADS_SD_CONTROL_SE_SACL_PRESENT = 16,
        ADS_SD_CONTROL_SE_SACL_DEFAULTED = 32,
        ADS_SD_CONTROL_SE_DACL_AUTO_INHERIT_REQ = 256,
        ADS_SD_CONTROL_SE_SACL_AUTO_INHERIT_REQ = 512,
        ADS_SD_CONTROL_SE_DACL_AUTO_INHERITED = 1024,
        ADS_SD_CONTROL_SE_SACL_AUTO_INHERITED = 2048,
        ADS_SD_CONTROL_SE_DACL_PROTECTED = 4096,
        ADS_SD_CONTROL_SE_SACL_PROTECTED = 8192,
        ADS_SD_CONTROL_SE_SELF_RELATIVE = 32768
    } __MIDL___MIDL__intf_0115_0005;

    typedef [public]
    __MIDL___MIDL__intf_0115_0006 ADS_SD_REVISION_ENUM;

    typedef enum {
        ADS_SD_REVISION_DS = 4
    } __MIDL___MIDL__intf_0115_0006;

    [
      odl,
      uuid(9068270B-0939-11D1-8BE1-00C04FD8D503),
      dual,
      oleautomation
    ]
    interface IADsLargeInteger : IDispatch {
        [id(0x00000002), propget]
        HRESULT HighPart([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT HighPart([in] long retval);
        [id(0x00000003), propget]
        HRESULT LowPart([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT LowPart([in] long retval);
    };

    [
      uuid(927971F5-0939-11D1-8BE1-00C04FD8D503)
    ]
    coclass LargeInteger {
        [default] interface IADsLargeInteger;
        interface IDispatch;
    };

    typedef [public]
    __MIDL___MIDL__intf_0116_0001 ADS_NAME_TYPE_ENUM;

    typedef enum {
        ADS_NAME_TYPE_1779 = 1,
        ADS_NAME_TYPE_CANONICAL = 2,
        ADS_NAME_TYPE_NT4 = 3,
        ADS_NAME_TYPE_DISPLAY = 4,
        ADS_NAME_TYPE_DOMAIN_SIMPLE = 5,
        ADS_NAME_TYPE_ENTERPRISE_SIMPLE = 6,
        ADS_NAME_TYPE_GUID = 7,
        ADS_NAME_TYPE_UNKNOWN = 8,
        ADS_NAME_TYPE_USER_PRINCIPAL_NAME = 9,
        ADS_NAME_TYPE_CANONICAL_EX = 10,
        ADS_NAME_TYPE_SERVICE_PRINCIPAL_NAME = 11
    } __MIDL___MIDL__intf_0116_0001;

    typedef [public]
    __MIDL___MIDL__intf_0116_0002 ADS_NAME_INITTYPE_ENUM;

    typedef enum {
        ADS_NAME_INITTYPE_DOMAIN = 1,
        ADS_NAME_INITTYPE_SERVER = 2,
        ADS_NAME_INITTYPE_GC = 3
    } __MIDL___MIDL__intf_0116_0002;

    [
      odl,
      uuid(B1B272A3-3625-11D1-A3A4-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsNameTranslate : IDispatch {
        [id(0x00000001), propput]
        HRESULT ChaseReferral([in] long rhs);
        [id(0x00000002)]
        HRESULT Init(
                        [in] long lnSetType, 
                        [in] BSTR bstrADsPath);
        [id(0x00000003)]
        HRESULT InitEx(
                        [in] long lnSetType, 
                        [in] BSTR bstrADsPath, 
                        [in] BSTR bstrUserID, 
                        [in] BSTR bstrDomain, 
                        [in] BSTR bstrPassword);
        [id(0x00000004)]
        HRESULT Set(
                        [in] long lnSetType, 
                        [in] BSTR bstrADsPath);
        [id(0x00000005)]
        HRESULT Get(
                        [in] long lnFormatType, 
                        [out, retval] BSTR* pbstrADsPath);
        [id(0x00000006)]
        HRESULT SetEx(
                        [in] long lnFormatType, 
                        [in] VARIANT pVar);
        [id(0x00000007)]
        HRESULT GetEx(
                        [in] long lnFormatType, 
                        [out, retval] VARIANT* pVar);
    };

    [
      uuid(274FAE1F-3626-11D1-A3A4-00C04FB950DC)
    ]
    coclass NameTranslate {
        [default] interface IADsNameTranslate;
        interface IDispatch;
    };

    [
      odl,
      uuid(7B66B533-4680-11D1-A3B4-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsCaseIgnoreList : IDispatch {
        [id(0x00000002), propget]
        HRESULT CaseIgnoreList([out, retval] VARIANT* retval);
        [id(0x00000002), propput]
        HRESULT CaseIgnoreList([in] VARIANT retval);
    };

    [
      uuid(15F88A55-4680-11D1-A3B4-00C04FB950DC)
    ]
    coclass CaseIgnoreList {
        [default] interface IADsCaseIgnoreList;
        interface IDispatch;
    };

    [
      odl,
      uuid(A910DEA9-4680-11D1-A3B4-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsFaxNumber : IDispatch {
        [id(0x00000002), propget]
        HRESULT TelephoneNumber([out, retval] BSTR* retval);
        [id(0x00000002), propput]
        HRESULT TelephoneNumber([in] BSTR retval);
        [id(0x00000003), propget]
        HRESULT Parameters([out, retval] VARIANT* retval);
        [id(0x00000003), propput]
        HRESULT Parameters([in] VARIANT retval);
    };

    [
      uuid(A5062215-4681-11D1-A3B4-00C04FB950DC)
    ]
    coclass FaxNumber {
        [default] interface IADsFaxNumber;
        interface IDispatch;
    };

    [
      odl,
      uuid(B21A50A9-4080-11D1-A3AC-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsNetAddress : IDispatch {
        [id(0x00000002), propget]
        HRESULT AddressType([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT AddressType([in] long retval);
        [id(0x00000003), propget]
        HRESULT Address([out, retval] VARIANT* retval);
        [id(0x00000003), propput]
        HRESULT Address([in] VARIANT retval);
    };

    [
      uuid(B0B71247-4080-11D1-A3AC-00C04FB950DC)
    ]
    coclass NetAddress {
        [default] interface IADsNetAddress;
        interface IDispatch;
    };

    [
      odl,
      uuid(7B28B80F-4680-11D1-A3B4-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsOctetList : IDispatch {
        [id(0x00000002), propget]
        HRESULT OctetList([out, retval] VARIANT* retval);
        [id(0x00000002), propput]
        HRESULT OctetList([in] VARIANT retval);
    };

    [
      uuid(1241400F-4680-11D1-A3B4-00C04FB950DC)
    ]
    coclass OctetList {
        [default] interface IADsOctetList;
        interface IDispatch;
    };

    [
      odl,
      uuid(97AF011A-478E-11D1-A3B4-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsEmail : IDispatch {
        [id(0x00000002), propget]
        HRESULT Type([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT Type([in] long retval);
        [id(0x00000003), propget]
        HRESULT Address([out, retval] BSTR* retval);
        [id(0x00000003), propput]
        HRESULT Address([in] BSTR retval);
    };

    [
      uuid(8F92A857-478E-11D1-A3B4-00C04FB950DC)
    ]
    coclass Email {
        [default] interface IADsEmail;
        interface IDispatch;
    };

    [
      odl,
      uuid(B287FCD5-4080-11D1-A3AC-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsPath : IDispatch {
        [id(0x00000002), propget]
        HRESULT Type([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT Type([in] long retval);
        [id(0x00000003), propget]
        HRESULT VolumeName([out, retval] BSTR* retval);
        [id(0x00000003), propput]
        HRESULT VolumeName([in] BSTR retval);
        [id(0x00000004), propget]
        HRESULT Path([out, retval] BSTR* retval);
        [id(0x00000004), propput]
        HRESULT Path([in] BSTR retval);
    };

    [
      uuid(B2538919-4080-11D1-A3AC-00C04FB950DC)
    ]
    coclass Path {
        [default] interface IADsPath;
        interface IDispatch;
    };

    [
      odl,
      uuid(F60FB803-4080-11D1-A3AC-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsReplicaPointer : IDispatch {
        [id(0x00000002), propget]
        HRESULT ServerName([out, retval] BSTR* retval);
        [id(0x00000002), propput]
        HRESULT ServerName([in] BSTR retval);
        [id(0x00000003), propget]
        HRESULT ReplicaType([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT ReplicaType([in] long retval);
        [id(0x00000004), propget]
        HRESULT ReplicaNumber([out, retval] long* retval);
        [id(0x00000004), propput]
        HRESULT ReplicaNumber([in] long retval);
        [id(0x00000005), propget]
        HRESULT Count([out, retval] long* retval);
        [id(0x00000005), propput]
        HRESULT Count([in] long retval);
        [id(0x00000006), propget]
        HRESULT ReplicaAddressHints([out, retval] VARIANT* retval);
        [id(0x00000006), propput]
        HRESULT ReplicaAddressHints([in] VARIANT retval);
    };

    [
      uuid(F5D1BADF-4080-11D1-A3AC-00C04FB950DC)
    ]
    coclass ReplicaPointer {
        [default] interface IADsReplicaPointer;
        interface IDispatch;
    };

    [
      odl,
      uuid(8452D3AB-0869-11D1-A377-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsAcl : IDispatch {
        [id(0x00000002), propget]
        HRESULT ProtectedAttrName([out, retval] BSTR* retval);
        [id(0x00000002), propput]
        HRESULT ProtectedAttrName([in] BSTR retval);
        [id(0x00000003), propget]
        HRESULT SubjectName([out, retval] BSTR* retval);
        [id(0x00000003), propput]
        HRESULT SubjectName([in] BSTR retval);
        [id(0x00000004), propget]
        HRESULT Privileges([out, retval] long* retval);
        [id(0x00000004), propput]
        HRESULT Privileges([in] long retval);
        [id(0x00000005)]
        HRESULT CopyAcl([out, retval] IDispatch** ppAcl);
    };

    [
      uuid(7AF1EFB6-0869-11D1-A377-00C04FB950DC)
    ]
    coclass Acl {
        [default] interface IADsAcl;
        interface IDispatch;
    };

    [
      odl,
      uuid(B2F5A901-4080-11D1-A3AC-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsTimestamp : IDispatch {
        [id(0x00000002), propget]
        HRESULT WholeSeconds([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT WholeSeconds([in] long retval);
        [id(0x00000003), propget]
        HRESULT EventID([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT EventID([in] long retval);
    };

    [
      uuid(B2BED2EB-4080-11D1-A3AC-00C04FB950DC)
    ]
    coclass Timestamp {
        [default] interface IADsTimestamp;
        interface IDispatch;
    };

    [
      odl,
      uuid(7ADECF29-4680-11D1-A3B4-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsPostalAddress : IDispatch {
        [id(0x00000002), propget]
        HRESULT PostalAddress([out, retval] VARIANT* retval);
        [id(0x00000002), propput]
        HRESULT PostalAddress([in] VARIANT retval);
    };

    [
      uuid(0A75AFCD-4680-11D1-A3B4-00C04FB950DC)
    ]
    coclass PostalAddress {
        [default] interface IADsPostalAddress;
        interface IDispatch;
    };

    [
      odl,
      uuid(FD1302BD-4080-11D1-A3AC-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsBackLink : IDispatch {
        [id(0x00000002), propget]
        HRESULT RemoteID([out, retval] long* retval);
        [id(0x00000002), propput]
        HRESULT RemoteID([in] long retval);
        [id(0x00000003), propget]
        HRESULT ObjectName([out, retval] BSTR* retval);
        [id(0x00000003), propput]
        HRESULT ObjectName([in] BSTR retval);
    };

    [
      uuid(FCBF906F-4080-11D1-A3AC-00C04FB950DC)
    ]
    coclass BackLink {
        [default] interface IADsBackLink;
        interface IDispatch;
    };

    [
      odl,
      uuid(B371A349-4080-11D1-A3AC-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsTypedName : IDispatch {
        [id(0x00000002), propget]
        HRESULT ObjectName([out, retval] BSTR* retval);
        [id(0x00000002), propput]
        HRESULT ObjectName([in] BSTR retval);
        [id(0x00000003), propget]
        HRESULT Level([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT Level([in] long retval);
        [id(0x00000004), propget]
        HRESULT Interval([out, retval] long* retval);
        [id(0x00000004), propput]
        HRESULT Interval([in] long retval);
    };

    [
      uuid(B33143CB-4080-11D1-A3AC-00C04FB950DC)
    ]
    coclass TypedName {
        [default] interface IADsTypedName;
        interface IDispatch;
    };

    [
      odl,
      uuid(B3EB3B37-4080-11D1-A3AC-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsHold : IDispatch {
        [id(0x00000002), propget]
        HRESULT ObjectName([out, retval] BSTR* retval);
        [id(0x00000002), propput]
        HRESULT ObjectName([in] BSTR retval);
        [id(0x00000003), propget]
        HRESULT Amount([out, retval] long* retval);
        [id(0x00000003), propput]
        HRESULT Amount([in] long retval);
    };

    [
      uuid(B3AD3E13-4080-11D1-A3AC-00C04FB950DC)
    ]
    coclass Hold {
        [default] interface IADsHold;
        interface IDispatch;
    };

    typedef [public]
    __MIDL___MIDL__intf_0130_0001 ADS_OPTION_ENUM;

    typedef enum {
        ADS_OPTION_SERVERNAME = 0,
        ADS_OPTION_REFERRALS = 1,
        ADS_OPTION_PAGE_SIZE = 2,
        ADS_OPTION_SECURITY_MASK = 3
    } __MIDL___MIDL__intf_0130_0001;

    typedef [public]
    __MIDL___MIDL__intf_0130_0002 ADS_SECURITY_INFO_ENUM;

    typedef enum {
        ADS_SECURITY_INFO_OWNER = 1,
        ADS_SECURITY_INFO_GROUP = 2,
        ADS_SECURITY_INFO_DACL = 4,
        ADS_SECURITY_INFO_SACL = 8
    } __MIDL___MIDL__intf_0130_0002;

    [
      odl,
      uuid(46F14FDA-232B-11D1-A808-00C04FD8D5A8),
      dual,
      oleautomation
    ]
    interface IADsObjectOptions : IDispatch {
        [id(0x00000002)]
        HRESULT GetOption(
                        [in] long lnOption, 
                        [out, retval] VARIANT* pvValue);
        [id(0x00000003)]
        HRESULT SetOption(
                        [in] long lnOption, 
                        [in] VARIANT vValue);
    };

    typedef [public]
    __MIDL___MIDL__intf_0131_0001 ADS_SETTYPE_ENUM;

    typedef enum {
        ADS_SETTYPE_FULL = 1,
        ADS_SETTYPE_PROVIDER = 2,
        ADS_SETTYPE_SERVER = 3,
        ADS_SETTYPE_DN = 4
    } __MIDL___MIDL__intf_0131_0001;

    typedef [public]
    __MIDL___MIDL__intf_0131_0002 ADS_FORMAT_ENUM;

    typedef enum {
        ADS_FORMAT_WINDOWS = 1,
        ADS_FORMAT_WINDOWS_NO_SERVER = 2,
        ADS_FORMAT_WINDOWS_DN = 3,
        ADS_FORMAT_WINDOWS_PARENT = 4,
        ADS_FORMAT_X500 = 5,
        ADS_FORMAT_X500_NO_SERVER = 6,
        ADS_FORMAT_X500_DN = 7,
        ADS_FORMAT_X500_PARENT = 8,
        ADS_FORMAT_SERVER = 9,
        ADS_FORMAT_PROVIDER = 10,
        ADS_FORMAT_LEAF = 11
    } __MIDL___MIDL__intf_0131_0002;

    typedef [public]
    __MIDL___MIDL__intf_0131_0003 ADS_DISPLAY_ENUM;

    typedef enum {
        ADS_DISPLAY_FULL = 1,
        ADS_DISPLAY_VALUE_ONLY = 2
    } __MIDL___MIDL__intf_0131_0003;

    typedef [public]
    __MIDL___MIDL__intf_0131_0004 ADS_ESCAPE_MODE_ENUM;

    typedef enum {
        ADS_ESCAPEDMODE_DEFAULT = 1,
        ADS_ESCAPEDMODE_ON = 2,
        ADS_ESCAPEDMODE_OFF = 3
    } __MIDL___MIDL__intf_0131_0004;

    [
      odl,
      uuid(D592AED4-F420-11D0-A36E-00C04FB950DC),
      dual,
      oleautomation
    ]
    interface IADsPathname : IDispatch {
        [id(0x00000002)]
        HRESULT Set(
                        [in] BSTR bstrADsPath, 
                        [in] long lnSetType);
        [id(0x00000003)]
        HRESULT SetDisplayType([in] long lnDisplayType);
        [id(0x00000004)]
        HRESULT Retrieve(
                        [in] long lnFormatType, 
                        [out, retval] BSTR* pbstrADsPath);
        [id(0x00000005)]
        HRESULT GetNumElements([out, retval] long* plnNumPathElements);
        [id(0x00000006)]
        HRESULT GetElement(
                        [in] long lnElementIndex, 
                        [out, retval] BSTR* pbstrElement);
        [id(0x00000007)]
        HRESULT AddLeafElement([in] BSTR bstrLeafElement);
        [id(0x00000008)]
        HRESULT RemoveLeafElement();
        [id(0x00000009)]
        HRESULT CopyPath([out, retval] IDispatch** ppAdsPath);
        [id(0x0000000a)]
        HRESULT GetEscapedElement(
                        [in] long lnReserved, 
                        [in] BSTR bstrInStr, 
                        [out, retval] BSTR* pbstrOutStr);
        [id(0x0000000b), propget]
        HRESULT EscapedMode([out, retval] long* retval);
        [id(0x0000000b), propput]
        HRESULT EscapedMode([in] long retval);
    };

    [
      uuid(080D0D78-F421-11D0-A36E-00C04FB950DC)
    ]
    coclass Pathname {
        [default] interface IADsPathname;
        interface IDispatch;
    };
};