File Coverage

blib/lib/Paws/DS.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::DS;
2 1     1   7790 use Moose;
  1         4  
  1         17  
3             sub service { 'ds' }
4             sub version { '2015-04-16' }
5             sub target_prefix { 'DirectoryService_20150416' }
6             sub json_version { "1.1" }
7             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8             has retry => (is => 'ro', isa => 'HashRef', default => sub {
9             { base => 'rand', type => 'exponential', growth_factor => 2 }
10             });
11             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12             ] });
13              
14             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller', 'Paws::Net::JsonResponse';
15              
16            
17             sub AddIpRoutes {
18             my $self = shift;
19             my $call_object = $self->new_with_coercions('Paws::DS::AddIpRoutes', @_);
20             return $self->caller->do_call($self, $call_object);
21             }
22             sub AddTagsToResource {
23             my $self = shift;
24             my $call_object = $self->new_with_coercions('Paws::DS::AddTagsToResource', @_);
25             return $self->caller->do_call($self, $call_object);
26             }
27             sub CancelSchemaExtension {
28             my $self = shift;
29             my $call_object = $self->new_with_coercions('Paws::DS::CancelSchemaExtension', @_);
30             return $self->caller->do_call($self, $call_object);
31             }
32             sub ConnectDirectory {
33             my $self = shift;
34             my $call_object = $self->new_with_coercions('Paws::DS::ConnectDirectory', @_);
35             return $self->caller->do_call($self, $call_object);
36             }
37             sub CreateAlias {
38             my $self = shift;
39             my $call_object = $self->new_with_coercions('Paws::DS::CreateAlias', @_);
40             return $self->caller->do_call($self, $call_object);
41             }
42             sub CreateComputer {
43             my $self = shift;
44             my $call_object = $self->new_with_coercions('Paws::DS::CreateComputer', @_);
45             return $self->caller->do_call($self, $call_object);
46             }
47             sub CreateConditionalForwarder {
48             my $self = shift;
49             my $call_object = $self->new_with_coercions('Paws::DS::CreateConditionalForwarder', @_);
50             return $self->caller->do_call($self, $call_object);
51             }
52             sub CreateDirectory {
53             my $self = shift;
54             my $call_object = $self->new_with_coercions('Paws::DS::CreateDirectory', @_);
55             return $self->caller->do_call($self, $call_object);
56             }
57             sub CreateMicrosoftAD {
58             my $self = shift;
59             my $call_object = $self->new_with_coercions('Paws::DS::CreateMicrosoftAD', @_);
60             return $self->caller->do_call($self, $call_object);
61             }
62             sub CreateSnapshot {
63             my $self = shift;
64             my $call_object = $self->new_with_coercions('Paws::DS::CreateSnapshot', @_);
65             return $self->caller->do_call($self, $call_object);
66             }
67             sub CreateTrust {
68             my $self = shift;
69             my $call_object = $self->new_with_coercions('Paws::DS::CreateTrust', @_);
70             return $self->caller->do_call($self, $call_object);
71             }
72             sub DeleteConditionalForwarder {
73             my $self = shift;
74             my $call_object = $self->new_with_coercions('Paws::DS::DeleteConditionalForwarder', @_);
75             return $self->caller->do_call($self, $call_object);
76             }
77             sub DeleteDirectory {
78             my $self = shift;
79             my $call_object = $self->new_with_coercions('Paws::DS::DeleteDirectory', @_);
80             return $self->caller->do_call($self, $call_object);
81             }
82             sub DeleteSnapshot {
83             my $self = shift;
84             my $call_object = $self->new_with_coercions('Paws::DS::DeleteSnapshot', @_);
85             return $self->caller->do_call($self, $call_object);
86             }
87             sub DeleteTrust {
88             my $self = shift;
89             my $call_object = $self->new_with_coercions('Paws::DS::DeleteTrust', @_);
90             return $self->caller->do_call($self, $call_object);
91             }
92             sub DeregisterEventTopic {
93             my $self = shift;
94             my $call_object = $self->new_with_coercions('Paws::DS::DeregisterEventTopic', @_);
95             return $self->caller->do_call($self, $call_object);
96             }
97             sub DescribeConditionalForwarders {
98             my $self = shift;
99             my $call_object = $self->new_with_coercions('Paws::DS::DescribeConditionalForwarders', @_);
100             return $self->caller->do_call($self, $call_object);
101             }
102             sub DescribeDirectories {
103             my $self = shift;
104             my $call_object = $self->new_with_coercions('Paws::DS::DescribeDirectories', @_);
105             return $self->caller->do_call($self, $call_object);
106             }
107             sub DescribeDomainControllers {
108             my $self = shift;
109             my $call_object = $self->new_with_coercions('Paws::DS::DescribeDomainControllers', @_);
110             return $self->caller->do_call($self, $call_object);
111             }
112             sub DescribeEventTopics {
113             my $self = shift;
114             my $call_object = $self->new_with_coercions('Paws::DS::DescribeEventTopics', @_);
115             return $self->caller->do_call($self, $call_object);
116             }
117             sub DescribeSnapshots {
118             my $self = shift;
119             my $call_object = $self->new_with_coercions('Paws::DS::DescribeSnapshots', @_);
120             return $self->caller->do_call($self, $call_object);
121             }
122             sub DescribeTrusts {
123             my $self = shift;
124             my $call_object = $self->new_with_coercions('Paws::DS::DescribeTrusts', @_);
125             return $self->caller->do_call($self, $call_object);
126             }
127             sub DisableRadius {
128             my $self = shift;
129             my $call_object = $self->new_with_coercions('Paws::DS::DisableRadius', @_);
130             return $self->caller->do_call($self, $call_object);
131             }
132             sub DisableSso {
133             my $self = shift;
134             my $call_object = $self->new_with_coercions('Paws::DS::DisableSso', @_);
135             return $self->caller->do_call($self, $call_object);
136             }
137             sub EnableRadius {
138             my $self = shift;
139             my $call_object = $self->new_with_coercions('Paws::DS::EnableRadius', @_);
140             return $self->caller->do_call($self, $call_object);
141             }
142             sub EnableSso {
143             my $self = shift;
144             my $call_object = $self->new_with_coercions('Paws::DS::EnableSso', @_);
145             return $self->caller->do_call($self, $call_object);
146             }
147             sub GetDirectoryLimits {
148             my $self = shift;
149             my $call_object = $self->new_with_coercions('Paws::DS::GetDirectoryLimits', @_);
150             return $self->caller->do_call($self, $call_object);
151             }
152             sub GetSnapshotLimits {
153             my $self = shift;
154             my $call_object = $self->new_with_coercions('Paws::DS::GetSnapshotLimits', @_);
155             return $self->caller->do_call($self, $call_object);
156             }
157             sub ListIpRoutes {
158             my $self = shift;
159             my $call_object = $self->new_with_coercions('Paws::DS::ListIpRoutes', @_);
160             return $self->caller->do_call($self, $call_object);
161             }
162             sub ListSchemaExtensions {
163             my $self = shift;
164             my $call_object = $self->new_with_coercions('Paws::DS::ListSchemaExtensions', @_);
165             return $self->caller->do_call($self, $call_object);
166             }
167             sub ListTagsForResource {
168             my $self = shift;
169             my $call_object = $self->new_with_coercions('Paws::DS::ListTagsForResource', @_);
170             return $self->caller->do_call($self, $call_object);
171             }
172             sub RegisterEventTopic {
173             my $self = shift;
174             my $call_object = $self->new_with_coercions('Paws::DS::RegisterEventTopic', @_);
175             return $self->caller->do_call($self, $call_object);
176             }
177             sub RemoveIpRoutes {
178             my $self = shift;
179             my $call_object = $self->new_with_coercions('Paws::DS::RemoveIpRoutes', @_);
180             return $self->caller->do_call($self, $call_object);
181             }
182             sub RemoveTagsFromResource {
183             my $self = shift;
184             my $call_object = $self->new_with_coercions('Paws::DS::RemoveTagsFromResource', @_);
185             return $self->caller->do_call($self, $call_object);
186             }
187             sub RestoreFromSnapshot {
188             my $self = shift;
189             my $call_object = $self->new_with_coercions('Paws::DS::RestoreFromSnapshot', @_);
190             return $self->caller->do_call($self, $call_object);
191             }
192             sub StartSchemaExtension {
193             my $self = shift;
194             my $call_object = $self->new_with_coercions('Paws::DS::StartSchemaExtension', @_);
195             return $self->caller->do_call($self, $call_object);
196             }
197             sub UpdateConditionalForwarder {
198             my $self = shift;
199             my $call_object = $self->new_with_coercions('Paws::DS::UpdateConditionalForwarder', @_);
200             return $self->caller->do_call($self, $call_object);
201             }
202             sub UpdateNumberOfDomainControllers {
203             my $self = shift;
204             my $call_object = $self->new_with_coercions('Paws::DS::UpdateNumberOfDomainControllers', @_);
205             return $self->caller->do_call($self, $call_object);
206             }
207             sub UpdateRadius {
208             my $self = shift;
209             my $call_object = $self->new_with_coercions('Paws::DS::UpdateRadius', @_);
210             return $self->caller->do_call($self, $call_object);
211             }
212             sub VerifyTrust {
213             my $self = shift;
214             my $call_object = $self->new_with_coercions('Paws::DS::VerifyTrust', @_);
215             return $self->caller->do_call($self, $call_object);
216             }
217            
218              
219              
220             sub operations { qw/AddIpRoutes AddTagsToResource CancelSchemaExtension ConnectDirectory CreateAlias CreateComputer CreateConditionalForwarder CreateDirectory CreateMicrosoftAD CreateSnapshot CreateTrust DeleteConditionalForwarder DeleteDirectory DeleteSnapshot DeleteTrust DeregisterEventTopic DescribeConditionalForwarders DescribeDirectories DescribeDomainControllers DescribeEventTopics DescribeSnapshots DescribeTrusts DisableRadius DisableSso EnableRadius EnableSso GetDirectoryLimits GetSnapshotLimits ListIpRoutes ListSchemaExtensions ListTagsForResource RegisterEventTopic RemoveIpRoutes RemoveTagsFromResource RestoreFromSnapshot StartSchemaExtension UpdateConditionalForwarder UpdateNumberOfDomainControllers UpdateRadius VerifyTrust / }
221              
222             1;
223              
224             ### main pod documentation begin ###
225              
226             =head1 NAME
227              
228             Paws::DS - Perl Interface to AWS AWS Directory Service
229              
230             =head1 SYNOPSIS
231              
232             use Paws;
233              
234             my $obj = Paws->service('DS');
235             my $res = $obj->Method(
236             Arg1 => $val1,
237             Arg2 => [ 'V1', 'V2' ],
238             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
239             # of the arguments type
240             Arg3 => { Att1 => 'Val1' },
241             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
242             # the constructor of the arguments type
243             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
244             );
245              
246             =head1 DESCRIPTION
247              
248             AWS Directory Service
249              
250             AWS Directory Service is a web service that makes it easy for you to
251             setup and run directories in the AWS cloud, or connect your AWS
252             resources with an existing on-premises Microsoft Active Directory. This
253             guide provides detailed information about AWS Directory Service
254             operations, data types, parameters, and errors. For information about
255             AWS Directory Services features, see AWS Directory Service and the AWS
256             Directory Service Administration Guide.
257              
258             AWS provides SDKs that consist of libraries and sample code for various
259             programming languages and platforms (Java, Ruby, .Net, iOS, Android,
260             etc.). The SDKs provide a convenient way to create programmatic access
261             to AWS Directory Service and other AWS services. For more information
262             about the AWS SDKs, including how to download and install them, see
263             Tools for Amazon Web Services.
264              
265             =head1 METHODS
266              
267             =head2 AddIpRoutes(DirectoryId => Str, IpRoutes => ArrayRef[L<Paws::DS::IpRoute>], [UpdateSecurityGroupForDirectoryControllers => Bool])
268              
269             Each argument is described in detail in: L<Paws::DS::AddIpRoutes>
270              
271             Returns: a L<Paws::DS::AddIpRoutesResult> instance
272              
273             If the DNS server for your on-premises domain uses a publicly
274             addressable IP address, you must add a CIDR address block to correctly
275             route traffic to and from your Microsoft AD on Amazon Web Services.
276             I<AddIpRoutes> adds this address block. You can also use I<AddIpRoutes>
277             to facilitate routing traffic that uses public IP ranges from your
278             Microsoft AD on AWS to a peer VPC.
279              
280             Before you call I<AddIpRoutes>, ensure that all of the required
281             permissions have been explicitly granted through a policy. For details
282             about what permissions are required to run the I<AddIpRoutes>
283             operation, see AWS Directory Service API Permissions: Actions,
284             Resources, and Conditions Reference.
285              
286              
287             =head2 AddTagsToResource(ResourceId => Str, Tags => ArrayRef[L<Paws::DS::Tag>])
288              
289             Each argument is described in detail in: L<Paws::DS::AddTagsToResource>
290              
291             Returns: a L<Paws::DS::AddTagsToResourceResult> instance
292              
293             Adds or overwrites one or more tags for the specified directory. Each
294             directory can have a maximum of 50 tags. Each tag consists of a key and
295             optional value. Tag keys must be unique to each resource.
296              
297              
298             =head2 CancelSchemaExtension(DirectoryId => Str, SchemaExtensionId => Str)
299              
300             Each argument is described in detail in: L<Paws::DS::CancelSchemaExtension>
301              
302             Returns: a L<Paws::DS::CancelSchemaExtensionResult> instance
303              
304             Cancels an in-progress schema extension to a Microsoft AD directory.
305             Once a schema extension has started replicating to all domain
306             controllers, the task can no longer be canceled. A schema extension can
307             be canceled during any of the following states; C<Initializing>,
308             C<CreatingSnapshot>, and C<UpdatingSchema>.
309              
310              
311             =head2 ConnectDirectory(ConnectSettings => L<Paws::DS::DirectoryConnectSettings>, Name => Str, Password => Str, Size => Str, [Description => Str, ShortName => Str])
312              
313             Each argument is described in detail in: L<Paws::DS::ConnectDirectory>
314              
315             Returns: a L<Paws::DS::ConnectDirectoryResult> instance
316              
317             Creates an AD Connector to connect to an on-premises directory.
318              
319             Before you call I<ConnectDirectory>, ensure that all of the required
320             permissions have been explicitly granted through a policy. For details
321             about what permissions are required to run the I<ConnectDirectory>
322             operation, see AWS Directory Service API Permissions: Actions,
323             Resources, and Conditions Reference.
324              
325              
326             =head2 CreateAlias(Alias => Str, DirectoryId => Str)
327              
328             Each argument is described in detail in: L<Paws::DS::CreateAlias>
329              
330             Returns: a L<Paws::DS::CreateAliasResult> instance
331              
332             Creates an alias for a directory and assigns the alias to the
333             directory. The alias is used to construct the access URL for the
334             directory, such as C<http://E<lt>aliasE<gt>.awsapps.com>.
335              
336             After an alias has been created, it cannot be deleted or reused, so
337             this operation should only be used when absolutely necessary.
338              
339              
340             =head2 CreateComputer(ComputerName => Str, DirectoryId => Str, Password => Str, [ComputerAttributes => ArrayRef[L<Paws::DS::Attribute>], OrganizationalUnitDistinguishedName => Str])
341              
342             Each argument is described in detail in: L<Paws::DS::CreateComputer>
343              
344             Returns: a L<Paws::DS::CreateComputerResult> instance
345              
346             Creates a computer account in the specified directory, and joins the
347             computer to the directory.
348              
349              
350             =head2 CreateConditionalForwarder(DirectoryId => Str, DnsIpAddrs => ArrayRef[Str|Undef], RemoteDomainName => Str)
351              
352             Each argument is described in detail in: L<Paws::DS::CreateConditionalForwarder>
353              
354             Returns: a L<Paws::DS::CreateConditionalForwarderResult> instance
355              
356             Creates a conditional forwarder associated with your AWS directory.
357             Conditional forwarders are required in order to set up a trust
358             relationship with another domain. The conditional forwarder points to
359             the trusted domain.
360              
361              
362             =head2 CreateDirectory(Name => Str, Password => Str, Size => Str, [Description => Str, ShortName => Str, VpcSettings => L<Paws::DS::DirectoryVpcSettings>])
363              
364             Each argument is described in detail in: L<Paws::DS::CreateDirectory>
365              
366             Returns: a L<Paws::DS::CreateDirectoryResult> instance
367              
368             Creates a Simple AD directory.
369              
370             Before you call I<CreateDirectory>, ensure that all of the required
371             permissions have been explicitly granted through a policy. For details
372             about what permissions are required to run the I<CreateDirectory>
373             operation, see AWS Directory Service API Permissions: Actions,
374             Resources, and Conditions Reference.
375              
376              
377             =head2 CreateMicrosoftAD(Name => Str, Password => Str, VpcSettings => L<Paws::DS::DirectoryVpcSettings>, [Description => Str, ShortName => Str])
378              
379             Each argument is described in detail in: L<Paws::DS::CreateMicrosoftAD>
380              
381             Returns: a L<Paws::DS::CreateMicrosoftADResult> instance
382              
383             Creates a Microsoft AD in the AWS cloud.
384              
385             Before you call I<CreateMicrosoftAD>, ensure that all of the required
386             permissions have been explicitly granted through a policy. For details
387             about what permissions are required to run the I<CreateMicrosoftAD>
388             operation, see AWS Directory Service API Permissions: Actions,
389             Resources, and Conditions Reference.
390              
391              
392             =head2 CreateSnapshot(DirectoryId => Str, [Name => Str])
393              
394             Each argument is described in detail in: L<Paws::DS::CreateSnapshot>
395              
396             Returns: a L<Paws::DS::CreateSnapshotResult> instance
397              
398             Creates a snapshot of a Simple AD or Microsoft AD directory in the AWS
399             cloud.
400              
401             You cannot take snapshots of AD Connector directories.
402              
403              
404             =head2 CreateTrust(DirectoryId => Str, RemoteDomainName => Str, TrustDirection => Str, TrustPassword => Str, [ConditionalForwarderIpAddrs => ArrayRef[Str|Undef], TrustType => Str])
405              
406             Each argument is described in detail in: L<Paws::DS::CreateTrust>
407              
408             Returns: a L<Paws::DS::CreateTrustResult> instance
409              
410             AWS Directory Service for Microsoft Active Directory allows you to
411             configure trust relationships. For example, you can establish a trust
412             between your Microsoft AD in the AWS cloud, and your existing
413             on-premises Microsoft Active Directory. This would allow you to provide
414             users and groups access to resources in either domain, with a single
415             set of credentials.
416              
417             This action initiates the creation of the AWS side of a trust
418             relationship between a Microsoft AD in the AWS cloud and an external
419             domain.
420              
421              
422             =head2 DeleteConditionalForwarder(DirectoryId => Str, RemoteDomainName => Str)
423              
424             Each argument is described in detail in: L<Paws::DS::DeleteConditionalForwarder>
425              
426             Returns: a L<Paws::DS::DeleteConditionalForwarderResult> instance
427              
428             Deletes a conditional forwarder that has been set up for your AWS
429             directory.
430              
431              
432             =head2 DeleteDirectory(DirectoryId => Str)
433              
434             Each argument is described in detail in: L<Paws::DS::DeleteDirectory>
435              
436             Returns: a L<Paws::DS::DeleteDirectoryResult> instance
437              
438             Deletes an AWS Directory Service directory.
439              
440             Before you call I<DeleteDirectory>, ensure that all of the required
441             permissions have been explicitly granted through a policy. For details
442             about what permissions are required to run the I<DeleteDirectory>
443             operation, see AWS Directory Service API Permissions: Actions,
444             Resources, and Conditions Reference.
445              
446              
447             =head2 DeleteSnapshot(SnapshotId => Str)
448              
449             Each argument is described in detail in: L<Paws::DS::DeleteSnapshot>
450              
451             Returns: a L<Paws::DS::DeleteSnapshotResult> instance
452              
453             Deletes a directory snapshot.
454              
455              
456             =head2 DeleteTrust(TrustId => Str, [DeleteAssociatedConditionalForwarder => Bool])
457              
458             Each argument is described in detail in: L<Paws::DS::DeleteTrust>
459              
460             Returns: a L<Paws::DS::DeleteTrustResult> instance
461              
462             Deletes an existing trust relationship between your Microsoft AD in the
463             AWS cloud and an external domain.
464              
465              
466             =head2 DeregisterEventTopic(DirectoryId => Str, TopicName => Str)
467              
468             Each argument is described in detail in: L<Paws::DS::DeregisterEventTopic>
469              
470             Returns: a L<Paws::DS::DeregisterEventTopicResult> instance
471              
472             Removes the specified directory as a publisher to the specified SNS
473             topic.
474              
475              
476             =head2 DescribeConditionalForwarders(DirectoryId => Str, [RemoteDomainNames => ArrayRef[Str|Undef]])
477              
478             Each argument is described in detail in: L<Paws::DS::DescribeConditionalForwarders>
479              
480             Returns: a L<Paws::DS::DescribeConditionalForwardersResult> instance
481              
482             Obtains information about the conditional forwarders for this account.
483              
484             If no input parameters are provided for RemoteDomainNames, this request
485             describes all conditional forwarders for the specified directory ID.
486              
487              
488             =head2 DescribeDirectories([DirectoryIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
489              
490             Each argument is described in detail in: L<Paws::DS::DescribeDirectories>
491              
492             Returns: a L<Paws::DS::DescribeDirectoriesResult> instance
493              
494             Obtains information about the directories that belong to this account.
495              
496             You can retrieve information about specific directories by passing the
497             directory identifiers in the I<DirectoryIds> parameter. Otherwise, all
498             directories that belong to the current account are returned.
499              
500             This operation supports pagination with the use of the I<NextToken>
501             request and response parameters. If more results are available, the
502             I<DescribeDirectoriesResult.NextToken> member contains a token that you
503             pass in the next call to DescribeDirectories to retrieve the next set
504             of items.
505              
506             You can also specify a maximum number of return results with the
507             I<Limit> parameter.
508              
509              
510             =head2 DescribeDomainControllers(DirectoryId => Str, [DomainControllerIds => ArrayRef[Str|Undef], Limit => Int, NextToken => Str])
511              
512             Each argument is described in detail in: L<Paws::DS::DescribeDomainControllers>
513              
514             Returns: a L<Paws::DS::DescribeDomainControllersResult> instance
515              
516             Provides information about any domain controllers in your directory.
517              
518              
519             =head2 DescribeEventTopics([DirectoryId => Str, TopicNames => ArrayRef[Str|Undef]])
520              
521             Each argument is described in detail in: L<Paws::DS::DescribeEventTopics>
522              
523             Returns: a L<Paws::DS::DescribeEventTopicsResult> instance
524              
525             Obtains information about which SNS topics receive status messages from
526             the specified directory.
527              
528             If no input parameters are provided, such as DirectoryId or TopicName,
529             this request describes all of the associations in the account.
530              
531              
532             =head2 DescribeSnapshots([DirectoryId => Str, Limit => Int, NextToken => Str, SnapshotIds => ArrayRef[Str|Undef]])
533              
534             Each argument is described in detail in: L<Paws::DS::DescribeSnapshots>
535              
536             Returns: a L<Paws::DS::DescribeSnapshotsResult> instance
537              
538             Obtains information about the directory snapshots that belong to this
539             account.
540              
541             This operation supports pagination with the use of the I<NextToken>
542             request and response parameters. If more results are available, the
543             I<DescribeSnapshots.NextToken> member contains a token that you pass in
544             the next call to DescribeSnapshots to retrieve the next set of items.
545              
546             You can also specify a maximum number of return results with the
547             I<Limit> parameter.
548              
549              
550             =head2 DescribeTrusts([DirectoryId => Str, Limit => Int, NextToken => Str, TrustIds => ArrayRef[Str|Undef]])
551              
552             Each argument is described in detail in: L<Paws::DS::DescribeTrusts>
553              
554             Returns: a L<Paws::DS::DescribeTrustsResult> instance
555              
556             Obtains information about the trust relationships for this account.
557              
558             If no input parameters are provided, such as DirectoryId or TrustIds,
559             this request describes all the trust relationships belonging to the
560             account.
561              
562              
563             =head2 DisableRadius(DirectoryId => Str)
564              
565             Each argument is described in detail in: L<Paws::DS::DisableRadius>
566              
567             Returns: a L<Paws::DS::DisableRadiusResult> instance
568              
569             Disables multi-factor authentication (MFA) with the Remote
570             Authentication Dial In User Service (RADIUS) server for an AD Connector
571             directory.
572              
573              
574             =head2 DisableSso(DirectoryId => Str, [Password => Str, UserName => Str])
575              
576             Each argument is described in detail in: L<Paws::DS::DisableSso>
577              
578             Returns: a L<Paws::DS::DisableSsoResult> instance
579              
580             Disables single-sign on for a directory.
581              
582              
583             =head2 EnableRadius(DirectoryId => Str, RadiusSettings => L<Paws::DS::RadiusSettings>)
584              
585             Each argument is described in detail in: L<Paws::DS::EnableRadius>
586              
587             Returns: a L<Paws::DS::EnableRadiusResult> instance
588              
589             Enables multi-factor authentication (MFA) with the Remote
590             Authentication Dial In User Service (RADIUS) server for an AD Connector
591             directory.
592              
593              
594             =head2 EnableSso(DirectoryId => Str, [Password => Str, UserName => Str])
595              
596             Each argument is described in detail in: L<Paws::DS::EnableSso>
597              
598             Returns: a L<Paws::DS::EnableSsoResult> instance
599              
600             Enables single sign-on for a directory.
601              
602              
603             =head2 GetDirectoryLimits()
604              
605             Each argument is described in detail in: L<Paws::DS::GetDirectoryLimits>
606              
607             Returns: a L<Paws::DS::GetDirectoryLimitsResult> instance
608              
609             Obtains directory limit information for the current region.
610              
611              
612             =head2 GetSnapshotLimits(DirectoryId => Str)
613              
614             Each argument is described in detail in: L<Paws::DS::GetSnapshotLimits>
615              
616             Returns: a L<Paws::DS::GetSnapshotLimitsResult> instance
617              
618             Obtains the manual snapshot limits for a directory.
619              
620              
621             =head2 ListIpRoutes(DirectoryId => Str, [Limit => Int, NextToken => Str])
622              
623             Each argument is described in detail in: L<Paws::DS::ListIpRoutes>
624              
625             Returns: a L<Paws::DS::ListIpRoutesResult> instance
626              
627             Lists the address blocks that you have added to a directory.
628              
629              
630             =head2 ListSchemaExtensions(DirectoryId => Str, [Limit => Int, NextToken => Str])
631              
632             Each argument is described in detail in: L<Paws::DS::ListSchemaExtensions>
633              
634             Returns: a L<Paws::DS::ListSchemaExtensionsResult> instance
635              
636             Lists all schema extensions applied to a Microsoft AD Directory.
637              
638              
639             =head2 ListTagsForResource(ResourceId => Str, [Limit => Int, NextToken => Str])
640              
641             Each argument is described in detail in: L<Paws::DS::ListTagsForResource>
642              
643             Returns: a L<Paws::DS::ListTagsForResourceResult> instance
644              
645             Lists all tags on a directory.
646              
647              
648             =head2 RegisterEventTopic(DirectoryId => Str, TopicName => Str)
649              
650             Each argument is described in detail in: L<Paws::DS::RegisterEventTopic>
651              
652             Returns: a L<Paws::DS::RegisterEventTopicResult> instance
653              
654             Associates a directory with an SNS topic. This establishes the
655             directory as a publisher to the specified SNS topic. You can then
656             receive email or text (SMS) messages when the status of your directory
657             changes. You get notified if your directory goes from an Active status
658             to an Impaired or Inoperable status. You also receive a notification
659             when the directory returns to an Active status.
660              
661              
662             =head2 RemoveIpRoutes(CidrIps => ArrayRef[Str|Undef], DirectoryId => Str)
663              
664             Each argument is described in detail in: L<Paws::DS::RemoveIpRoutes>
665              
666             Returns: a L<Paws::DS::RemoveIpRoutesResult> instance
667              
668             Removes IP address blocks from a directory.
669              
670              
671             =head2 RemoveTagsFromResource(ResourceId => Str, TagKeys => ArrayRef[Str|Undef])
672              
673             Each argument is described in detail in: L<Paws::DS::RemoveTagsFromResource>
674              
675             Returns: a L<Paws::DS::RemoveTagsFromResourceResult> instance
676              
677             Removes tags from a directory.
678              
679              
680             =head2 RestoreFromSnapshot(SnapshotId => Str)
681              
682             Each argument is described in detail in: L<Paws::DS::RestoreFromSnapshot>
683              
684             Returns: a L<Paws::DS::RestoreFromSnapshotResult> instance
685              
686             Restores a directory using an existing directory snapshot.
687              
688             When you restore a directory from a snapshot, any changes made to the
689             directory after the snapshot date are overwritten.
690              
691             This action returns as soon as the restore operation is initiated. You
692             can monitor the progress of the restore operation by calling the
693             DescribeDirectories operation with the directory identifier. When the
694             B<DirectoryDescription.Stage> value changes to C<Active>, the restore
695             operation is complete.
696              
697              
698             =head2 StartSchemaExtension(CreateSnapshotBeforeSchemaExtension => Bool, Description => Str, DirectoryId => Str, LdifContent => Str)
699              
700             Each argument is described in detail in: L<Paws::DS::StartSchemaExtension>
701              
702             Returns: a L<Paws::DS::StartSchemaExtensionResult> instance
703              
704             Applies a schema extension to a Microsoft AD directory.
705              
706              
707             =head2 UpdateConditionalForwarder(DirectoryId => Str, DnsIpAddrs => ArrayRef[Str|Undef], RemoteDomainName => Str)
708              
709             Each argument is described in detail in: L<Paws::DS::UpdateConditionalForwarder>
710              
711             Returns: a L<Paws::DS::UpdateConditionalForwarderResult> instance
712              
713             Updates a conditional forwarder that has been set up for your AWS
714             directory.
715              
716              
717             =head2 UpdateNumberOfDomainControllers(DesiredNumber => Int, DirectoryId => Str)
718              
719             Each argument is described in detail in: L<Paws::DS::UpdateNumberOfDomainControllers>
720              
721             Returns: a L<Paws::DS::UpdateNumberOfDomainControllersResult> instance
722              
723             Adds or removes domain controllers to or from the directory. Based on
724             the difference between current value and new value (provided through
725             this API call), domain controllers will be added or removed. It may
726             take up to 45 minutes for any new domain controllers to become fully
727             active once the requested number of domain controllers is updated.
728             During this time, you cannot make another update request.
729              
730              
731             =head2 UpdateRadius(DirectoryId => Str, RadiusSettings => L<Paws::DS::RadiusSettings>)
732              
733             Each argument is described in detail in: L<Paws::DS::UpdateRadius>
734              
735             Returns: a L<Paws::DS::UpdateRadiusResult> instance
736              
737             Updates the Remote Authentication Dial In User Service (RADIUS) server
738             information for an AD Connector directory.
739              
740              
741             =head2 VerifyTrust(TrustId => Str)
742              
743             Each argument is described in detail in: L<Paws::DS::VerifyTrust>
744              
745             Returns: a L<Paws::DS::VerifyTrustResult> instance
746              
747             AWS Directory Service for Microsoft Active Directory allows you to
748             configure and verify trust relationships.
749              
750             This action verifies a trust relationship between your Microsoft AD in
751             the AWS cloud and an external domain.
752              
753              
754              
755              
756             =head1 PAGINATORS
757              
758             Paginator methods are helpers that repetively call methods that return partial results
759              
760              
761              
762              
763             =head1 SEE ALSO
764              
765             This service class forms part of L<Paws>
766              
767             =head1 BUGS and CONTRIBUTIONS
768              
769             The source code is located here: https://github.com/pplu/aws-sdk-perl
770              
771             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
772              
773             =cut
774