File Coverage

blib/lib/Paws/Organizations.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::Organizations;
2 1     1   2302 use Moose;
  1         3  
  1         9  
3             sub service { 'organizations' }
4             sub version { '2016-11-28' }
5             sub target_prefix { 'AWSOrganizationsV20161128' }
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 AcceptHandshake {
18             my $self = shift;
19             my $call_object = $self->new_with_coercions('Paws::Organizations::AcceptHandshake', @_);
20             return $self->caller->do_call($self, $call_object);
21             }
22             sub AttachPolicy {
23             my $self = shift;
24             my $call_object = $self->new_with_coercions('Paws::Organizations::AttachPolicy', @_);
25             return $self->caller->do_call($self, $call_object);
26             }
27             sub CancelHandshake {
28             my $self = shift;
29             my $call_object = $self->new_with_coercions('Paws::Organizations::CancelHandshake', @_);
30             return $self->caller->do_call($self, $call_object);
31             }
32             sub CreateAccount {
33             my $self = shift;
34             my $call_object = $self->new_with_coercions('Paws::Organizations::CreateAccount', @_);
35             return $self->caller->do_call($self, $call_object);
36             }
37             sub CreateOrganization {
38             my $self = shift;
39             my $call_object = $self->new_with_coercions('Paws::Organizations::CreateOrganization', @_);
40             return $self->caller->do_call($self, $call_object);
41             }
42             sub CreateOrganizationalUnit {
43             my $self = shift;
44             my $call_object = $self->new_with_coercions('Paws::Organizations::CreateOrganizationalUnit', @_);
45             return $self->caller->do_call($self, $call_object);
46             }
47             sub CreatePolicy {
48             my $self = shift;
49             my $call_object = $self->new_with_coercions('Paws::Organizations::CreatePolicy', @_);
50             return $self->caller->do_call($self, $call_object);
51             }
52             sub DeclineHandshake {
53             my $self = shift;
54             my $call_object = $self->new_with_coercions('Paws::Organizations::DeclineHandshake', @_);
55             return $self->caller->do_call($self, $call_object);
56             }
57             sub DeleteOrganization {
58             my $self = shift;
59             my $call_object = $self->new_with_coercions('Paws::Organizations::DeleteOrganization', @_);
60             return $self->caller->do_call($self, $call_object);
61             }
62             sub DeleteOrganizationalUnit {
63             my $self = shift;
64             my $call_object = $self->new_with_coercions('Paws::Organizations::DeleteOrganizationalUnit', @_);
65             return $self->caller->do_call($self, $call_object);
66             }
67             sub DeletePolicy {
68             my $self = shift;
69             my $call_object = $self->new_with_coercions('Paws::Organizations::DeletePolicy', @_);
70             return $self->caller->do_call($self, $call_object);
71             }
72             sub DescribeAccount {
73             my $self = shift;
74             my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeAccount', @_);
75             return $self->caller->do_call($self, $call_object);
76             }
77             sub DescribeCreateAccountStatus {
78             my $self = shift;
79             my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeCreateAccountStatus', @_);
80             return $self->caller->do_call($self, $call_object);
81             }
82             sub DescribeHandshake {
83             my $self = shift;
84             my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeHandshake', @_);
85             return $self->caller->do_call($self, $call_object);
86             }
87             sub DescribeOrganization {
88             my $self = shift;
89             my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeOrganization', @_);
90             return $self->caller->do_call($self, $call_object);
91             }
92             sub DescribeOrganizationalUnit {
93             my $self = shift;
94             my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeOrganizationalUnit', @_);
95             return $self->caller->do_call($self, $call_object);
96             }
97             sub DescribePolicy {
98             my $self = shift;
99             my $call_object = $self->new_with_coercions('Paws::Organizations::DescribePolicy', @_);
100             return $self->caller->do_call($self, $call_object);
101             }
102             sub DetachPolicy {
103             my $self = shift;
104             my $call_object = $self->new_with_coercions('Paws::Organizations::DetachPolicy', @_);
105             return $self->caller->do_call($self, $call_object);
106             }
107             sub DisablePolicyType {
108             my $self = shift;
109             my $call_object = $self->new_with_coercions('Paws::Organizations::DisablePolicyType', @_);
110             return $self->caller->do_call($self, $call_object);
111             }
112             sub EnableAllFeatures {
113             my $self = shift;
114             my $call_object = $self->new_with_coercions('Paws::Organizations::EnableAllFeatures', @_);
115             return $self->caller->do_call($self, $call_object);
116             }
117             sub EnablePolicyType {
118             my $self = shift;
119             my $call_object = $self->new_with_coercions('Paws::Organizations::EnablePolicyType', @_);
120             return $self->caller->do_call($self, $call_object);
121             }
122             sub InviteAccountToOrganization {
123             my $self = shift;
124             my $call_object = $self->new_with_coercions('Paws::Organizations::InviteAccountToOrganization', @_);
125             return $self->caller->do_call($self, $call_object);
126             }
127             sub LeaveOrganization {
128             my $self = shift;
129             my $call_object = $self->new_with_coercions('Paws::Organizations::LeaveOrganization', @_);
130             return $self->caller->do_call($self, $call_object);
131             }
132             sub ListAccounts {
133             my $self = shift;
134             my $call_object = $self->new_with_coercions('Paws::Organizations::ListAccounts', @_);
135             return $self->caller->do_call($self, $call_object);
136             }
137             sub ListAccountsForParent {
138             my $self = shift;
139             my $call_object = $self->new_with_coercions('Paws::Organizations::ListAccountsForParent', @_);
140             return $self->caller->do_call($self, $call_object);
141             }
142             sub ListChildren {
143             my $self = shift;
144             my $call_object = $self->new_with_coercions('Paws::Organizations::ListChildren', @_);
145             return $self->caller->do_call($self, $call_object);
146             }
147             sub ListCreateAccountStatus {
148             my $self = shift;
149             my $call_object = $self->new_with_coercions('Paws::Organizations::ListCreateAccountStatus', @_);
150             return $self->caller->do_call($self, $call_object);
151             }
152             sub ListHandshakesForAccount {
153             my $self = shift;
154             my $call_object = $self->new_with_coercions('Paws::Organizations::ListHandshakesForAccount', @_);
155             return $self->caller->do_call($self, $call_object);
156             }
157             sub ListHandshakesForOrganization {
158             my $self = shift;
159             my $call_object = $self->new_with_coercions('Paws::Organizations::ListHandshakesForOrganization', @_);
160             return $self->caller->do_call($self, $call_object);
161             }
162             sub ListOrganizationalUnitsForParent {
163             my $self = shift;
164             my $call_object = $self->new_with_coercions('Paws::Organizations::ListOrganizationalUnitsForParent', @_);
165             return $self->caller->do_call($self, $call_object);
166             }
167             sub ListParents {
168             my $self = shift;
169             my $call_object = $self->new_with_coercions('Paws::Organizations::ListParents', @_);
170             return $self->caller->do_call($self, $call_object);
171             }
172             sub ListPolicies {
173             my $self = shift;
174             my $call_object = $self->new_with_coercions('Paws::Organizations::ListPolicies', @_);
175             return $self->caller->do_call($self, $call_object);
176             }
177             sub ListPoliciesForTarget {
178             my $self = shift;
179             my $call_object = $self->new_with_coercions('Paws::Organizations::ListPoliciesForTarget', @_);
180             return $self->caller->do_call($self, $call_object);
181             }
182             sub ListRoots {
183             my $self = shift;
184             my $call_object = $self->new_with_coercions('Paws::Organizations::ListRoots', @_);
185             return $self->caller->do_call($self, $call_object);
186             }
187             sub ListTargetsForPolicy {
188             my $self = shift;
189             my $call_object = $self->new_with_coercions('Paws::Organizations::ListTargetsForPolicy', @_);
190             return $self->caller->do_call($self, $call_object);
191             }
192             sub MoveAccount {
193             my $self = shift;
194             my $call_object = $self->new_with_coercions('Paws::Organizations::MoveAccount', @_);
195             return $self->caller->do_call($self, $call_object);
196             }
197             sub RemoveAccountFromOrganization {
198             my $self = shift;
199             my $call_object = $self->new_with_coercions('Paws::Organizations::RemoveAccountFromOrganization', @_);
200             return $self->caller->do_call($self, $call_object);
201             }
202             sub UpdateOrganizationalUnit {
203             my $self = shift;
204             my $call_object = $self->new_with_coercions('Paws::Organizations::UpdateOrganizationalUnit', @_);
205             return $self->caller->do_call($self, $call_object);
206             }
207             sub UpdatePolicy {
208             my $self = shift;
209             my $call_object = $self->new_with_coercions('Paws::Organizations::UpdatePolicy', @_);
210             return $self->caller->do_call($self, $call_object);
211             }
212            
213             sub ListAllAccounts {
214             my $self = shift;
215              
216             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
217             my $result = $self->ListAccounts(@_);
218             my $next_result = $result;
219              
220             if (not defined $callback) {
221             while ($next_result->NextToken) {
222             $next_result = $self->ListAccounts(@_, NextToken => $next_result->NextToken);
223             push @{ $result->Accounts }, @{ $next_result->Accounts };
224             }
225             return $result;
226             } else {
227             while ($result->NextToken) {
228             $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
229             $result = $self->ListAccounts(@_, NextToken => $result->NextToken);
230             }
231             $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
232             }
233              
234             return undef
235             }
236             sub ListAllAccountsForParent {
237             my $self = shift;
238              
239             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
240             my $result = $self->ListAccountsForParent(@_);
241             my $next_result = $result;
242              
243             if (not defined $callback) {
244             while ($next_result->NextToken) {
245             $next_result = $self->ListAccountsForParent(@_, NextToken => $next_result->NextToken);
246             push @{ $result->Accounts }, @{ $next_result->Accounts };
247             }
248             return $result;
249             } else {
250             while ($result->NextToken) {
251             $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
252             $result = $self->ListAccountsForParent(@_, NextToken => $result->NextToken);
253             }
254             $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
255             }
256              
257             return undef
258             }
259             sub ListAllChildren {
260             my $self = shift;
261              
262             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
263             my $result = $self->ListChildren(@_);
264             my $next_result = $result;
265              
266             if (not defined $callback) {
267             while ($next_result->NextToken) {
268             $next_result = $self->ListChildren(@_, NextToken => $next_result->NextToken);
269             push @{ $result->Children }, @{ $next_result->Children };
270             }
271             return $result;
272             } else {
273             while ($result->NextToken) {
274             $callback->($_ => 'Children') foreach (@{ $result->Children });
275             $result = $self->ListChildren(@_, NextToken => $result->NextToken);
276             }
277             $callback->($_ => 'Children') foreach (@{ $result->Children });
278             }
279              
280             return undef
281             }
282             sub ListAllCreateAccountStatus {
283             my $self = shift;
284              
285             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
286             my $result = $self->ListCreateAccountStatus(@_);
287             my $next_result = $result;
288              
289             if (not defined $callback) {
290             while ($next_result->NextToken) {
291             $next_result = $self->ListCreateAccountStatus(@_, NextToken => $next_result->NextToken);
292             push @{ $result->CreateAccountStatuses }, @{ $next_result->CreateAccountStatuses };
293             }
294             return $result;
295             } else {
296             while ($result->NextToken) {
297             $callback->($_ => 'CreateAccountStatuses') foreach (@{ $result->CreateAccountStatuses });
298             $result = $self->ListCreateAccountStatus(@_, NextToken => $result->NextToken);
299             }
300             $callback->($_ => 'CreateAccountStatuses') foreach (@{ $result->CreateAccountStatuses });
301             }
302              
303             return undef
304             }
305             sub ListAllHandshakesForAccount {
306             my $self = shift;
307              
308             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
309             my $result = $self->ListHandshakesForAccount(@_);
310             my $next_result = $result;
311              
312             if (not defined $callback) {
313             while ($next_result->NextToken) {
314             $next_result = $self->ListHandshakesForAccount(@_, NextToken => $next_result->NextToken);
315             push @{ $result->Handshakes }, @{ $next_result->Handshakes };
316             }
317             return $result;
318             } else {
319             while ($result->NextToken) {
320             $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
321             $result = $self->ListHandshakesForAccount(@_, NextToken => $result->NextToken);
322             }
323             $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
324             }
325              
326             return undef
327             }
328             sub ListAllHandshakesForOrganization {
329             my $self = shift;
330              
331             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
332             my $result = $self->ListHandshakesForOrganization(@_);
333             my $next_result = $result;
334              
335             if (not defined $callback) {
336             while ($next_result->NextToken) {
337             $next_result = $self->ListHandshakesForOrganization(@_, NextToken => $next_result->NextToken);
338             push @{ $result->Handshakes }, @{ $next_result->Handshakes };
339             }
340             return $result;
341             } else {
342             while ($result->NextToken) {
343             $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
344             $result = $self->ListHandshakesForOrganization(@_, NextToken => $result->NextToken);
345             }
346             $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
347             }
348              
349             return undef
350             }
351             sub ListAllOrganizationalUnitsForParent {
352             my $self = shift;
353              
354             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
355             my $result = $self->ListOrganizationalUnitsForParent(@_);
356             my $next_result = $result;
357              
358             if (not defined $callback) {
359             while ($next_result->NextToken) {
360             $next_result = $self->ListOrganizationalUnitsForParent(@_, NextToken => $next_result->NextToken);
361             push @{ $result->OrganizationalUnits }, @{ $next_result->OrganizationalUnits };
362             }
363             return $result;
364             } else {
365             while ($result->NextToken) {
366             $callback->($_ => 'OrganizationalUnits') foreach (@{ $result->OrganizationalUnits });
367             $result = $self->ListOrganizationalUnitsForParent(@_, NextToken => $result->NextToken);
368             }
369             $callback->($_ => 'OrganizationalUnits') foreach (@{ $result->OrganizationalUnits });
370             }
371              
372             return undef
373             }
374             sub ListAllParents {
375             my $self = shift;
376              
377             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
378             my $result = $self->ListParents(@_);
379             my $next_result = $result;
380              
381             if (not defined $callback) {
382             while ($next_result->NextToken) {
383             $next_result = $self->ListParents(@_, NextToken => $next_result->NextToken);
384             push @{ $result->Parents }, @{ $next_result->Parents };
385             }
386             return $result;
387             } else {
388             while ($result->NextToken) {
389             $callback->($_ => 'Parents') foreach (@{ $result->Parents });
390             $result = $self->ListParents(@_, NextToken => $result->NextToken);
391             }
392             $callback->($_ => 'Parents') foreach (@{ $result->Parents });
393             }
394              
395             return undef
396             }
397             sub ListAllPolicies {
398             my $self = shift;
399              
400             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
401             my $result = $self->ListPolicies(@_);
402             my $next_result = $result;
403              
404             if (not defined $callback) {
405             while ($next_result->NextToken) {
406             $next_result = $self->ListPolicies(@_, NextToken => $next_result->NextToken);
407             push @{ $result->Policies }, @{ $next_result->Policies };
408             }
409             return $result;
410             } else {
411             while ($result->NextToken) {
412             $callback->($_ => 'Policies') foreach (@{ $result->Policies });
413             $result = $self->ListPolicies(@_, NextToken => $result->NextToken);
414             }
415             $callback->($_ => 'Policies') foreach (@{ $result->Policies });
416             }
417              
418             return undef
419             }
420             sub ListAllPoliciesForTarget {
421             my $self = shift;
422              
423             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
424             my $result = $self->ListPoliciesForTarget(@_);
425             my $next_result = $result;
426              
427             if (not defined $callback) {
428             while ($next_result->NextToken) {
429             $next_result = $self->ListPoliciesForTarget(@_, NextToken => $next_result->NextToken);
430             push @{ $result->Policies }, @{ $next_result->Policies };
431             }
432             return $result;
433             } else {
434             while ($result->NextToken) {
435             $callback->($_ => 'Policies') foreach (@{ $result->Policies });
436             $result = $self->ListPoliciesForTarget(@_, NextToken => $result->NextToken);
437             }
438             $callback->($_ => 'Policies') foreach (@{ $result->Policies });
439             }
440              
441             return undef
442             }
443             sub ListAllRoots {
444             my $self = shift;
445              
446             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
447             my $result = $self->ListRoots(@_);
448             my $next_result = $result;
449              
450             if (not defined $callback) {
451             while ($next_result->NextToken) {
452             $next_result = $self->ListRoots(@_, NextToken => $next_result->NextToken);
453             push @{ $result->Roots }, @{ $next_result->Roots };
454             }
455             return $result;
456             } else {
457             while ($result->NextToken) {
458             $callback->($_ => 'Roots') foreach (@{ $result->Roots });
459             $result = $self->ListRoots(@_, NextToken => $result->NextToken);
460             }
461             $callback->($_ => 'Roots') foreach (@{ $result->Roots });
462             }
463              
464             return undef
465             }
466             sub ListAllTargetsForPolicy {
467             my $self = shift;
468              
469             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
470             my $result = $self->ListTargetsForPolicy(@_);
471             my $next_result = $result;
472              
473             if (not defined $callback) {
474             while ($next_result->NextToken) {
475             $next_result = $self->ListTargetsForPolicy(@_, NextToken => $next_result->NextToken);
476             push @{ $result->Targets }, @{ $next_result->Targets };
477             }
478             return $result;
479             } else {
480             while ($result->NextToken) {
481             $callback->($_ => 'Targets') foreach (@{ $result->Targets });
482             $result = $self->ListTargetsForPolicy(@_, NextToken => $result->NextToken);
483             }
484             $callback->($_ => 'Targets') foreach (@{ $result->Targets });
485             }
486              
487             return undef
488             }
489              
490              
491             sub operations { qw/AcceptHandshake AttachPolicy CancelHandshake CreateAccount CreateOrganization CreateOrganizationalUnit CreatePolicy DeclineHandshake DeleteOrganization DeleteOrganizationalUnit DeletePolicy DescribeAccount DescribeCreateAccountStatus DescribeHandshake DescribeOrganization DescribeOrganizationalUnit DescribePolicy DetachPolicy DisablePolicyType EnableAllFeatures EnablePolicyType InviteAccountToOrganization LeaveOrganization ListAccounts ListAccountsForParent ListChildren ListCreateAccountStatus ListHandshakesForAccount ListHandshakesForOrganization ListOrganizationalUnitsForParent ListParents ListPolicies ListPoliciesForTarget ListRoots ListTargetsForPolicy MoveAccount RemoveAccountFromOrganization UpdateOrganizationalUnit UpdatePolicy / }
492              
493             1;
494              
495             ### main pod documentation begin ###
496              
497             =head1 NAME
498              
499             Paws::Organizations - Perl Interface to AWS AWS Organizations
500              
501             =head1 SYNOPSIS
502              
503             use Paws;
504              
505             my $obj = Paws->service('Organizations');
506             my $res = $obj->Method(
507             Arg1 => $val1,
508             Arg2 => [ 'V1', 'V2' ],
509             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
510             # of the arguments type
511             Arg3 => { Att1 => 'Val1' },
512             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
513             # the constructor of the arguments type
514             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
515             );
516              
517             =head1 DESCRIPTION
518              
519             AWS Organizations API Reference
520              
521             AWS Organizations is a web service that enables you to consolidate your
522             multiple AWS accounts into an I<organization> and centrally manage your
523             accounts and their resources.
524              
525             This guide provides descriptions of the Organizations API. For more
526             information about using this service, see the AWS Organizations User
527             Guide.
528              
529             B<API Version>
530              
531             This version of the Organizations API Reference documents the
532             Organizations API version 2016-11-28.
533              
534             As an alternative to using the API directly, you can use one of the AWS
535             SDKs, which consist of libraries and sample code for various
536             programming languages and platforms (Java, Ruby, .NET, iOS, Android,
537             and more). The SDKs provide a convenient way to create programmatic
538             access to AWS Organizations. For example, the SDKs take care of
539             cryptographically signing requests, managing errors, and retrying
540             requests automatically. For more information about the AWS SDKs,
541             including how to download and install them, see Tools for Amazon Web
542             Services.
543              
544             We recommend that you use the AWS SDKs to make programmatic API calls
545             to Organizations. However, you also can use the Organizations Query API
546             to make direct calls to the Organizations web service. To learn more
547             about the Organizations Query API, see Making Query Requests in the
548             I<AWS Organizations User Guide>. Organizations supports GET and POST
549             requests for all actions. That is, the API does not require you to use
550             GET for some actions and POST for others. However, GET requests are
551             subject to the limitation size of a URL. Therefore, for operations that
552             require larger sizes, use a POST request.
553              
554             B<Signing Requests>
555              
556             When you send HTTP requests to AWS, you must sign the requests so that
557             AWS can identify who sent them. You sign requests with your AWS access
558             key, which consists of an access key ID and a secret access key. We
559             strongly recommend that you do not create an access key for your root
560             account. Anyone who has the access key for your root account has
561             unrestricted access to all the resources in your account. Instead,
562             create an access key for an IAM user account that has administrative
563             privileges. As another option, use AWS Security Token Service to
564             generate temporary security credentials, and use those credentials to
565             sign requests.
566              
567             To sign requests, we recommend that you use Signature Version 4. If you
568             have an existing application that uses Signature Version 2, you do not
569             have to update it to use Signature Version 4. However, some operations
570             now require Signature Version 4. The documentation for operations that
571             require version 4 indicate this requirement.
572              
573             When you use the AWS Command Line Interface (AWS CLI) or one of the AWS
574             SDKs to make requests to AWS, these tools automatically sign the
575             requests for you with the access key that you specify when you
576             configure the tools.
577              
578             In this release, each organization can have only one root. In a future
579             release, a single organization will support multiple roots.
580              
581             B<Support and Feedback for AWS Organizations>
582              
583             We welcome your feedback. Send your comments to
584             feedback-awsorganizations@amazon.com or post your feedback and
585             questions in our private AWS Organizations support forum. If you don't
586             have access to the forum, send a request for access to the email
587             address, along with your forum user ID. For more information about the
588             AWS support forums, see Forums Help.
589              
590             B<Endpoint to Call When Using the CLI or the AWS API>
591              
592             For the current release of Organizations, you must specify the
593             C<us-east-1> region for all AWS API and CLI calls. You can do this in
594             the CLI by using these parameters and commands:
595              
596             =over
597              
598             =item *
599              
600             Use the following parameter with each command to specify both the
601             endpoint and its region:
602              
603             C<--endpoint-url https://organizations.us-east-1.amazonaws.com>
604              
605             =item *
606              
607             Use the default endpoint, but configure your default region with this
608             command:
609              
610             C<aws configure set default.region us-east-1>
611              
612             =item *
613              
614             Use the following parameter with each command to specify the endpoint:
615              
616             C<--region us-east-1>
617              
618             =back
619              
620             For the various SDKs used to call the APIs, see the documentation for
621             the SDK of interest to learn how to direct the requests to a specific
622             endpoint. For more information, see Regions and Endpoints in the I<AWS
623             General Reference>.
624              
625             B<How examples are presented>
626              
627             The JSON returned by the AWS Organizations service as response to your
628             requests is returned as a single long string without line breaks or
629             formatting whitespace. Both line breaks and whitespace are included in
630             the examples in this guide to improve readability. When example input
631             parameters also would result in long strings that would extend beyond
632             the screen, we insert line breaks to enhance readability. You should
633             always submit the input as a single JSON text string.
634              
635             B<Recording API Requests>
636              
637             AWS Organizations supports AWS CloudTrail, a service that records AWS
638             API calls for your AWS account and delivers log files to an Amazon S3
639             bucket. By using information collected by AWS CloudTrail, you can
640             determine which requests were successfully made to Organizations, who
641             made the request, when it was made, and so on. For more about AWS
642             Organizations and its support for AWS CloudTrail, see Logging AWS
643             Organizations Events with AWS CloudTrail in the I<AWS Organizations
644             User Guide>. To learn more about CloudTrail, including how to turn it
645             on and find your log files, see the AWS CloudTrail User Guide.
646              
647             =head1 METHODS
648              
649             =head2 AcceptHandshake(HandshakeId => Str)
650              
651             Each argument is described in detail in: L<Paws::Organizations::AcceptHandshake>
652              
653             Returns: a L<Paws::Organizations::AcceptHandshakeResponse> instance
654              
655             Sends a response to the originator of a handshake agreeing to the
656             action proposed by the handshake request.
657              
658             This operation can be called only by the following principals when they
659             also have the relevant IAM permissions:
660              
661             =over
662              
663             =item *
664              
665             B<Invitation to join> or B<Approve all features request> handshakes:
666             only a principal from the member account.
667              
668             =item *
669              
670             B<Enable all features final confirmation> handshake: only a principal
671             from the master account.
672              
673             For more information about invitations, see Inviting an AWS Account to
674             Join Your Organization in the I<AWS Organizations User Guide>. For more
675             information about requests to enable all features in the organization,
676             see Enabling All Features in Your Organization in the I<AWS
677             Organizations User Guide>.
678              
679             =back
680              
681             After you accept a handshake, it continues to appear in the results of
682             relevant APIs for only 30 days. After that it is deleted.
683              
684              
685             =head2 AttachPolicy(PolicyId => Str, TargetId => Str)
686              
687             Each argument is described in detail in: L<Paws::Organizations::AttachPolicy>
688              
689             Returns: nothing
690              
691             Attaches a policy to a root, an organizational unit, or an individual
692             account. How the policy affects accounts depends on the type of policy:
693              
694             =over
695              
696             =item *
697              
698             B<Service control policy (SCP)> - An SCP specifies what permissions can
699             be delegated to users in affected member accounts. The scope of
700             influence for a policy depends on what you attach the policy to:
701              
702             =over
703              
704             =item *
705              
706             If you attach an SCP to a root, it affects all accounts in the
707             organization.
708              
709             =item *
710              
711             If you attach an SCP to an OU, it affects all accounts in that OU and
712             in any child OUs.
713              
714             =item *
715              
716             If you attach the policy directly to an account, then it affects only
717             that account.
718              
719             =back
720              
721             SCPs essentially are permission "filters". When you attach one SCP to a
722             higher level root or OU, and you also attach a different SCP to a child
723             OU or to an account, the child policy can further restrict only the
724             permissions that pass through the parent filter and are available to
725             the child. An SCP that is attached to a child cannot grant a permission
726             that is not already granted by the parent. For example, imagine that
727             the parent SCP allows permissions A, B, C, D, and E. The child SCP
728             allows C, D, E, F, and G. The result is that the accounts affected by
729             the child SCP are allowed to use only C, D, and E. They cannot use A or
730             B because they were filtered out by the child OU. They also cannot use
731             F and G because they were filtered out by the parent OU. They cannot be
732             granted back by the child SCP; child SCPs can only filter the
733             permissions they receive from the parent SCP.
734              
735             AWS Organizations attaches a default SCP named C<"FullAWSAccess> to
736             every root, OU, and account. This default SCP allows all services and
737             actions, enabling any new child OU or account to inherit the
738             permissions of the parent root or OU. If you detach the default policy,
739             you must replace it with a policy that specifies the permissions that
740             you want to allow in that OU or account.
741              
742             For more information about how Organizations policies permissions work,
743             see Using Service Control Policies in the I<AWS Organizations User
744             Guide>.
745              
746             =back
747              
748             This operation can be called only from the organization's master
749             account.
750              
751              
752             =head2 CancelHandshake(HandshakeId => Str)
753              
754             Each argument is described in detail in: L<Paws::Organizations::CancelHandshake>
755              
756             Returns: a L<Paws::Organizations::CancelHandshakeResponse> instance
757              
758             Cancels a handshake. Canceling a handshake sets the handshake state to
759             C<CANCELED>.
760              
761             This operation can be called only from the account that originated the
762             handshake. The recipient of the handshake can't cancel it, but can use
763             DeclineHandshake instead. After a handshake is canceled, the recipient
764             can no longer respond to that handshake.
765              
766             After you cancel a handshake, it continues to appear in the results of
767             relevant APIs for only 30 days. After that it is deleted.
768              
769              
770             =head2 CreateAccount(AccountName => Str, Email => Str, [IamUserAccessToBilling => Str, RoleName => Str])
771              
772             Each argument is described in detail in: L<Paws::Organizations::CreateAccount>
773              
774             Returns: a L<Paws::Organizations::CreateAccountResponse> instance
775              
776             Creates an AWS account that is automatically a member of the
777             organization whose credentials made the request. This is an
778             asynchronous request that AWS performs in the background. If you want
779             to check the status of the request later, you need the C<OperationId>
780             response element from this operation to provide as a parameter to the
781             DescribeCreateAccountStatus operation.
782              
783             AWS Organizations preconfigures the new member account with a role
784             (named C<OrganizationAccountAccessRole> by default) that grants
785             administrator permissions to the new account. Principals in the master
786             account can assume the role. AWS Organizations clones the company name
787             and address information for the new account from the organization's
788             master account.
789              
790             For more information about creating accounts, see Creating an AWS
791             Account in Your Organization in the I<AWS Organizations User Guide>.
792              
793             When you create an account in an organization using the AWS
794             Organizations console, API, or CLI commands, the information required
795             for the account to operate as a standalone account, such as a payment
796             method and signing the End User Licence Agreement (EULA) is I<not>
797             automatically collected. If you must remove an account from your
798             organization later, you can do so only after you provide the missing
799             information. Follow the steps at To leave an organization when all
800             required account information has not yet been provided in the I<AWS
801             Organizations User Guide>.
802              
803             When you create a member account with this operation, you can choose
804             whether to create the account with the B<IAM User and Role Access to
805             Billing Information> switch enabled. If you enable it, IAM users and
806             roles that have appropriate permissions can view billing information
807             for the account. If you disable this, then only the account root user
808             can access billing information. For information about how to disable
809             this for an account, see Granting Access to Your Billing Information
810             and Tools.
811              
812             This operation can be called only from the organization's master
813             account.
814              
815             If you get an exception that indicates that you exceeded your account
816             limits for the organization or that you can"t add an account because
817             your organization is still initializing, please contact AWS Customer
818             Support.
819              
820              
821             =head2 CreateOrganization([FeatureSet => Str])
822              
823             Each argument is described in detail in: L<Paws::Organizations::CreateOrganization>
824              
825             Returns: a L<Paws::Organizations::CreateOrganizationResponse> instance
826              
827             Creates an AWS organization. The account whose user is calling the
828             CreateOrganization operation automatically becomes the master account
829             of the new organization.
830              
831             This operation must be called using credentials from the account that
832             is to become the new organization's master account. The principal must
833             also have the relevant IAM permissions.
834              
835             By default (or if you set the C<FeatureSet> parameter to C<ALL>), the
836             new organization is created with all features enabled and service
837             control policies automatically enabled in the root. If you instead
838             choose to create the organization supporting only the consolidated
839             billing features by setting the C<FeatureSet> parameter to
840             C<CONSOLIDATED_BILLING">, then no policy types are enabled by default
841             and you cannot use organization policies.
842              
843              
844             =head2 CreateOrganizationalUnit(Name => Str, ParentId => Str)
845              
846             Each argument is described in detail in: L<Paws::Organizations::CreateOrganizationalUnit>
847              
848             Returns: a L<Paws::Organizations::CreateOrganizationalUnitResponse> instance
849              
850             Creates an organizational unit (OU) within a root or parent OU. An OU
851             is a container for accounts that enables you to organize your accounts
852             to apply policies according to your business requirements. The number
853             of levels deep that you can nest OUs is dependent upon the policy types
854             enabled for that root. For service control policies, the limit is five.
855              
856             For more information about OUs, see Managing Organizational Units in
857             the I<AWS Organizations User Guide>.
858              
859             This operation can be called only from the organization's master
860             account.
861              
862              
863             =head2 CreatePolicy(Content => Str, Description => Str, Name => Str, Type => Str)
864              
865             Each argument is described in detail in: L<Paws::Organizations::CreatePolicy>
866              
867             Returns: a L<Paws::Organizations::CreatePolicyResponse> instance
868              
869             Creates a policy of a specified type that you can attach to a root, an
870             organizational unit (OU), or an individual AWS account.
871              
872             For more information about policies and their use, see Managing
873             Organization Policies.
874              
875             This operation can be called only from the organization's master
876             account.
877              
878              
879             =head2 DeclineHandshake(HandshakeId => Str)
880              
881             Each argument is described in detail in: L<Paws::Organizations::DeclineHandshake>
882              
883             Returns: a L<Paws::Organizations::DeclineHandshakeResponse> instance
884              
885             Declines a handshake request. This sets the handshake state to
886             C<DECLINED> and effectively deactivates the request.
887              
888             This operation can be called only from the account that received the
889             handshake. The originator of the handshake can use CancelHandshake
890             instead. The originator can't reactivate a declined request, but can
891             re-initiate the process with a new handshake request.
892              
893             After you decline a handshake, it continues to appear in the results of
894             relevant APIs for only 30 days. After that it is deleted.
895              
896              
897             =head2 DeleteOrganization( => )
898              
899             Each argument is described in detail in: L<Paws::Organizations::DeleteOrganization>
900              
901             Returns: nothing
902              
903             Deletes the organization. You can delete an organization only by using
904             credentials from the master account. The organization must be empty of
905             member accounts, OUs, and policies.
906              
907              
908             =head2 DeleteOrganizationalUnit(OrganizationalUnitId => Str)
909              
910             Each argument is described in detail in: L<Paws::Organizations::DeleteOrganizationalUnit>
911              
912             Returns: nothing
913              
914             Deletes an organizational unit from a root or another OU. You must
915             first remove all accounts and child OUs from the OU that you want to
916             delete.
917              
918             This operation can be called only from the organization's master
919             account.
920              
921              
922             =head2 DeletePolicy(PolicyId => Str)
923              
924             Each argument is described in detail in: L<Paws::Organizations::DeletePolicy>
925              
926             Returns: nothing
927              
928             Deletes the specified policy from your organization. Before you perform
929             this operation, you must first detach the policy from all OUs, roots,
930             and accounts.
931              
932             This operation can be called only from the organization's master
933             account.
934              
935              
936             =head2 DescribeAccount(AccountId => Str)
937              
938             Each argument is described in detail in: L<Paws::Organizations::DescribeAccount>
939              
940             Returns: a L<Paws::Organizations::DescribeAccountResponse> instance
941              
942             Retrieves Organizations-related information about the specified
943             account.
944              
945             This operation can be called only from the organization's master
946             account.
947              
948              
949             =head2 DescribeCreateAccountStatus(CreateAccountRequestId => Str)
950              
951             Each argument is described in detail in: L<Paws::Organizations::DescribeCreateAccountStatus>
952              
953             Returns: a L<Paws::Organizations::DescribeCreateAccountStatusResponse> instance
954              
955             Retrieves the current status of an asynchronous request to create an
956             account.
957              
958             This operation can be called only from the organization's master
959             account.
960              
961              
962             =head2 DescribeHandshake(HandshakeId => Str)
963              
964             Each argument is described in detail in: L<Paws::Organizations::DescribeHandshake>
965              
966             Returns: a L<Paws::Organizations::DescribeHandshakeResponse> instance
967              
968             Retrieves information about a previously requested handshake. The
969             handshake ID comes from the response to the original
970             InviteAccountToOrganization operation that generated the handshake.
971              
972             You can access handshakes that are ACCEPTED, DECLINED, or CANCELED for
973             only 30 days after they change to that state. They are then deleted and
974             no longer accessible.
975              
976             This operation can be called from any account in the organization.
977              
978              
979             =head2 DescribeOrganization( => )
980              
981             Each argument is described in detail in: L<Paws::Organizations::DescribeOrganization>
982              
983             Returns: a L<Paws::Organizations::DescribeOrganizationResponse> instance
984              
985             Retrieves information about the organization that the user's account
986             belongs to.
987              
988             This operation can be called from any account in the organization.
989              
990              
991             =head2 DescribeOrganizationalUnit(OrganizationalUnitId => Str)
992              
993             Each argument is described in detail in: L<Paws::Organizations::DescribeOrganizationalUnit>
994              
995             Returns: a L<Paws::Organizations::DescribeOrganizationalUnitResponse> instance
996              
997             Retrieves information about an organizational unit (OU).
998              
999             This operation can be called only from the organization's master
1000             account.
1001              
1002              
1003             =head2 DescribePolicy(PolicyId => Str)
1004              
1005             Each argument is described in detail in: L<Paws::Organizations::DescribePolicy>
1006              
1007             Returns: a L<Paws::Organizations::DescribePolicyResponse> instance
1008              
1009             Retrieves information about a policy.
1010              
1011             This operation can be called only from the organization's master
1012             account.
1013              
1014              
1015             =head2 DetachPolicy(PolicyId => Str, TargetId => Str)
1016              
1017             Each argument is described in detail in: L<Paws::Organizations::DetachPolicy>
1018              
1019             Returns: nothing
1020              
1021             Detaches a policy from a target root, organizational unit, or account.
1022             If the policy being detached is a service control policy (SCP), the
1023             changes to permissions for IAM users and roles in affected accounts are
1024             immediate.
1025              
1026             B<Note:> Every root, OU, and account must have at least one SCP
1027             attached. If you want to replace the default C<FullAWSAccess> policy
1028             with one that limits the permissions that can be delegated, then you
1029             must attach the replacement policy before you can remove the default
1030             one. This is the authorization strategy of whitelisting. If you instead
1031             attach a second SCP and leave the C<FullAWSAccess> SCP still attached,
1032             and specify C<"Effect": "Deny"> in the second SCP to override the
1033             C<"Effect": "Allow"> in the C<FullAWSAccess> policy (or any other
1034             attached SCP), then you are using the authorization strategy of
1035             blacklisting.
1036              
1037             This operation can be called only from the organization's master
1038             account.
1039              
1040              
1041             =head2 DisablePolicyType(PolicyType => Str, RootId => Str)
1042              
1043             Each argument is described in detail in: L<Paws::Organizations::DisablePolicyType>
1044              
1045             Returns: a L<Paws::Organizations::DisablePolicyTypeResponse> instance
1046              
1047             Disables an organizational control policy type in a root. A policy of a
1048             certain type can be attached to entities in a root only if that type is
1049             enabled in the root. After you perform this operation, you no longer
1050             can attach policies of the specified type to that root or to any OU or
1051             account in that root. You can undo this by using the EnablePolicyType
1052             operation.
1053              
1054             This operation can be called only from the organization's master
1055             account.
1056              
1057              
1058             =head2 EnableAllFeatures()
1059              
1060             Each argument is described in detail in: L<Paws::Organizations::EnableAllFeatures>
1061              
1062             Returns: a L<Paws::Organizations::EnableAllFeaturesResponse> instance
1063              
1064             Enables all features in an organization. This enables the use of
1065             organization policies that can restrict the services and actions that
1066             can be called in each account. Until you enable all features, you have
1067             access only to consolidated billing, and you can't use any of the
1068             advanced account administration features that AWS Organizations
1069             supports. For more information, see Enabling All Features in Your
1070             Organization in the I<AWS Organizations User Guide>.
1071              
1072             This operation is required only for organizations that were created
1073             explicitly with only the consolidated billing features enabled, or that
1074             were migrated from a Consolidated Billing account family to
1075             Organizations. Calling this operation sends a handshake to every
1076             invited account in the organization. The feature set change can be
1077             finalized and the additional features enabled only after all
1078             administrators in the invited accounts approve the change by accepting
1079             the handshake.
1080              
1081             After all invited member accounts accept the handshake, you finalize
1082             the feature set change by accepting the handshake that contains
1083             C<"Action": "ENABLE_ALL_FEATURES">. This completes the change.
1084              
1085             After you enable all features in your organization, the master account
1086             in the organization can apply policies on all member accounts. These
1087             policies can restrict what users and even administrators in those
1088             accounts can do. The master account can apply policies that prevent
1089             accounts from leaving the organization. Ensure that your account
1090             administrators are aware of this.
1091              
1092             This operation can be called only from the organization's master
1093             account.
1094              
1095              
1096             =head2 EnablePolicyType(PolicyType => Str, RootId => Str)
1097              
1098             Each argument is described in detail in: L<Paws::Organizations::EnablePolicyType>
1099              
1100             Returns: a L<Paws::Organizations::EnablePolicyTypeResponse> instance
1101              
1102             Enables a policy type in a root. After you enable a policy type in a
1103             root, you can attach policies of that type to the root, any OU, or
1104             account in that root. You can undo this by using the DisablePolicyType
1105             operation.
1106              
1107             This operation can be called only from the organization's master
1108             account.
1109              
1110              
1111             =head2 InviteAccountToOrganization(Target => L<Paws::Organizations::HandshakeParty>, [Notes => Str])
1112              
1113             Each argument is described in detail in: L<Paws::Organizations::InviteAccountToOrganization>
1114              
1115             Returns: a L<Paws::Organizations::InviteAccountToOrganizationResponse> instance
1116              
1117             Sends an invitation to another account to join your organization as a
1118             member account. Organizations sends email on your behalf to the email
1119             address that is associated with the other account's owner. The
1120             invitation is implemented as a Handshake whose details are in the
1121             response.
1122              
1123             You can invite AWS accounts only from the same seller as the master
1124             account. For example, if your organization's master account was created
1125             by Amazon Internet Services Pvt. Ltd (AISPL), an AWS seller in India,
1126             then you can only invite other AISPL accounts to your organization. You
1127             can't combine accounts from AISPL and AWS, or any other AWS seller. For
1128             more information, see Consolidated Billing in India.
1129              
1130             This operation can be called only from the organization's master
1131             account.
1132              
1133             If you get an exception that indicates that you exceeded your account
1134             limits for the organization or that you can"t add an account because
1135             your organization is still initializing, please contact AWS Customer
1136             Support.
1137              
1138              
1139             =head2 LeaveOrganization( => )
1140              
1141             Each argument is described in detail in: L<Paws::Organizations::LeaveOrganization>
1142              
1143             Returns: nothing
1144              
1145             Removes a member account from its parent organization. This version of
1146             the operation is performed by the account that wants to leave. To
1147             remove a member account as a user in the master account, use
1148             RemoveAccountFromOrganization instead.
1149              
1150             This operation can be called only from a member account in the
1151             organization.
1152              
1153             =over
1154              
1155             =item *
1156              
1157             The master account in an organization with all features enabled can set
1158             service control policies (SCPs) that can restrict what administrators
1159             of member accounts can do, including preventing them from successfully
1160             calling C<LeaveOrganization> and leaving the organization.
1161              
1162             =item *
1163              
1164             You can leave an organization as a member account only if the account
1165             is configured with the information required to operate as a standalone
1166             account. When you create an account in an organization using the AWS
1167             Organizations console, API, or CLI commands, the information required
1168             of standalone accounts is I<not> automatically collected. For each
1169             account that you want to make standalone, you must accept the End User
1170             License Agreement (EULA), choose a support plan, provide and verify the
1171             required contact information, and provide a current payment method. AWS
1172             uses the payment method to charge for any billable (not free tier) AWS
1173             activity that occurs while the account is not attached to an
1174             organization. Follow the steps at To leave an organization when all
1175             required account information has not yet been provided in the I<AWS
1176             Organizations User Guide>.
1177              
1178             =item *
1179              
1180             You can leave an organization only after you enable IAM user access to
1181             billing in your account. For more information, see Activating Access to
1182             the Billing and Cost Management Console in the I<AWS Billing and Cost
1183             Management User Guide>.
1184              
1185             =back
1186              
1187              
1188              
1189             =head2 ListAccounts([MaxResults => Int, NextToken => Str])
1190              
1191             Each argument is described in detail in: L<Paws::Organizations::ListAccounts>
1192              
1193             Returns: a L<Paws::Organizations::ListAccountsResponse> instance
1194              
1195             Lists all the accounts in the organization. To request only the
1196             accounts in a root or OU, use the ListAccountsForParent operation
1197             instead.
1198              
1199             This operation can be called only from the organization's master
1200             account.
1201              
1202              
1203             =head2 ListAccountsForParent(ParentId => Str, [MaxResults => Int, NextToken => Str])
1204              
1205             Each argument is described in detail in: L<Paws::Organizations::ListAccountsForParent>
1206              
1207             Returns: a L<Paws::Organizations::ListAccountsForParentResponse> instance
1208              
1209             Lists the accounts in an organization that are contained by the
1210             specified target root or organizational unit (OU). If you specify the
1211             root, you get a list of all the accounts that are not in any OU. If you
1212             specify an OU, you get a list of all the accounts in only that OU, and
1213             not in any child OUs. To get a list of all accounts in the
1214             organization, use the ListAccounts operation.
1215              
1216              
1217             =head2 ListChildren(ChildType => Str, ParentId => Str, [MaxResults => Int, NextToken => Str])
1218              
1219             Each argument is described in detail in: L<Paws::Organizations::ListChildren>
1220              
1221             Returns: a L<Paws::Organizations::ListChildrenResponse> instance
1222              
1223             Lists all of the OUs or accounts that are contained in the specified
1224             parent OU or root. This operation, along with ListParents enables you
1225             to traverse the tree structure that makes up this root.
1226              
1227              
1228             =head2 ListCreateAccountStatus([MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef]])
1229              
1230             Each argument is described in detail in: L<Paws::Organizations::ListCreateAccountStatus>
1231              
1232             Returns: a L<Paws::Organizations::ListCreateAccountStatusResponse> instance
1233              
1234             Lists the account creation requests that match the specified status
1235             that is currently being tracked for the organization.
1236              
1237             This operation can be called only from the organization's master
1238             account.
1239              
1240              
1241             =head2 ListHandshakesForAccount([Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
1242              
1243             Each argument is described in detail in: L<Paws::Organizations::ListHandshakesForAccount>
1244              
1245             Returns: a L<Paws::Organizations::ListHandshakesForAccountResponse> instance
1246              
1247             Lists the current handshakes that are associated with the account of
1248             the requesting user.
1249              
1250             Handshakes that are ACCEPTED, DECLINED, or CANCELED appear in the
1251             results of this API for only 30 days after changing to that state.
1252             After that they are deleted and no longer accessible.
1253              
1254             This operation can be called from any account in the organization.
1255              
1256              
1257             =head2 ListHandshakesForOrganization([Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
1258              
1259             Each argument is described in detail in: L<Paws::Organizations::ListHandshakesForOrganization>
1260              
1261             Returns: a L<Paws::Organizations::ListHandshakesForOrganizationResponse> instance
1262              
1263             Lists the handshakes that are associated with the organization that the
1264             requesting user is part of. The C<ListHandshakesForOrganization>
1265             operation returns a list of handshake structures. Each structure
1266             contains details and status about a handshake.
1267              
1268             Handshakes that are ACCEPTED, DECLINED, or CANCELED appear in the
1269             results of this API for only 30 days after changing to that state.
1270             After that they are deleted and no longer accessible.
1271              
1272             This operation can be called only from the organization's master
1273             account.
1274              
1275              
1276             =head2 ListOrganizationalUnitsForParent(ParentId => Str, [MaxResults => Int, NextToken => Str])
1277              
1278             Each argument is described in detail in: L<Paws::Organizations::ListOrganizationalUnitsForParent>
1279              
1280             Returns: a L<Paws::Organizations::ListOrganizationalUnitsForParentResponse> instance
1281              
1282             Lists the organizational units (OUs) in a parent organizational unit or
1283             root.
1284              
1285             This operation can be called only from the organization's master
1286             account.
1287              
1288              
1289             =head2 ListParents(ChildId => Str, [MaxResults => Int, NextToken => Str])
1290              
1291             Each argument is described in detail in: L<Paws::Organizations::ListParents>
1292              
1293             Returns: a L<Paws::Organizations::ListParentsResponse> instance
1294              
1295             Lists the root or organizational units (OUs) that serve as the
1296             immediate parent of the specified child OU or account. This operation,
1297             along with ListChildren enables you to traverse the tree structure that
1298             makes up this root.
1299              
1300             This operation can be called only from the organization's master
1301             account.
1302              
1303             In the current release, a child can have only a single parent.
1304              
1305              
1306             =head2 ListPolicies(Filter => Str, [MaxResults => Int, NextToken => Str])
1307              
1308             Each argument is described in detail in: L<Paws::Organizations::ListPolicies>
1309              
1310             Returns: a L<Paws::Organizations::ListPoliciesResponse> instance
1311              
1312             Retrieves the list of all policies in an organization of a specified
1313             type.
1314              
1315             This operation can be called only from the organization's master
1316             account.
1317              
1318              
1319             =head2 ListPoliciesForTarget(Filter => Str, TargetId => Str, [MaxResults => Int, NextToken => Str])
1320              
1321             Each argument is described in detail in: L<Paws::Organizations::ListPoliciesForTarget>
1322              
1323             Returns: a L<Paws::Organizations::ListPoliciesForTargetResponse> instance
1324              
1325             Lists the policies that are directly attached to the specified target
1326             root, organizational unit (OU), or account. You must specify the policy
1327             type that you want included in the returned list.
1328              
1329             This operation can be called only from the organization's master
1330             account.
1331              
1332              
1333             =head2 ListRoots([MaxResults => Int, NextToken => Str])
1334              
1335             Each argument is described in detail in: L<Paws::Organizations::ListRoots>
1336              
1337             Returns: a L<Paws::Organizations::ListRootsResponse> instance
1338              
1339             Lists the roots that are defined in the current organization.
1340              
1341             This operation can be called only from the organization's master
1342             account.
1343              
1344              
1345             =head2 ListTargetsForPolicy(PolicyId => Str, [MaxResults => Int, NextToken => Str])
1346              
1347             Each argument is described in detail in: L<Paws::Organizations::ListTargetsForPolicy>
1348              
1349             Returns: a L<Paws::Organizations::ListTargetsForPolicyResponse> instance
1350              
1351             Lists all the roots, OUs, and accounts to which the specified policy is
1352             attached.
1353              
1354             This operation can be called only from the organization's master
1355             account.
1356              
1357              
1358             =head2 MoveAccount(AccountId => Str, DestinationParentId => Str, SourceParentId => Str)
1359              
1360             Each argument is described in detail in: L<Paws::Organizations::MoveAccount>
1361              
1362             Returns: nothing
1363              
1364             Moves an account from its current source parent root or OU to the
1365             specified destination parent root or OU.
1366              
1367             This operation can be called only from the organization's master
1368             account.
1369              
1370              
1371             =head2 RemoveAccountFromOrganization(AccountId => Str)
1372              
1373             Each argument is described in detail in: L<Paws::Organizations::RemoveAccountFromOrganization>
1374              
1375             Returns: nothing
1376              
1377             Removes the specified account from the organization.
1378              
1379             The removed account becomes a stand-alone account that is not a member
1380             of any organization. It is no longer subject to any policies and is
1381             responsible for its own bill payments. The organization's master
1382             account is no longer charged for any expenses accrued by the member
1383             account after it is removed from the organization.
1384              
1385             This operation can be called only from the organization's master
1386             account. Member accounts can remove themselves with LeaveOrganization
1387             instead.
1388              
1389             =over
1390              
1391             =item *
1392              
1393             You can remove an account from your organization only if the account is
1394             configured with the information required to operate as a standalone
1395             account. When you create an account in an organization using the AWS
1396             Organizations console, API, or CLI commands, the information required
1397             of standalone accounts is I<not> automatically collected. For an
1398             account that you want to make standalone, you must accept the End User
1399             License Agreement (EULA), choose a support plan, provide and verify the
1400             required contact information, and provide a current payment method. AWS
1401             uses the payment method to charge for any billable (not free tier) AWS
1402             activity that occurs while the account is not attached to an
1403             organization. To remove an account that does not yet have this
1404             information, you must sign in as the member account and follow the
1405             steps at To leave an organization when all required account information
1406             has not yet been provided in the I<AWS Organizations User Guide>.
1407              
1408             =item *
1409              
1410             You can remove a member account only after you enable IAM user access
1411             to billing in the member account. For more information, see Activating
1412             Access to the Billing and Cost Management Console in the I<AWS Billing
1413             and Cost Management User Guide>.
1414              
1415             =back
1416              
1417              
1418              
1419             =head2 UpdateOrganizationalUnit(OrganizationalUnitId => Str, [Name => Str])
1420              
1421             Each argument is described in detail in: L<Paws::Organizations::UpdateOrganizationalUnit>
1422              
1423             Returns: a L<Paws::Organizations::UpdateOrganizationalUnitResponse> instance
1424              
1425             Renames the specified organizational unit (OU). The ID and ARN do not
1426             change. The child OUs and accounts remain in place, and any attached
1427             policies of the OU remain attached.
1428              
1429             This operation can be called only from the organization's master
1430             account.
1431              
1432              
1433             =head2 UpdatePolicy(PolicyId => Str, [Content => Str, Description => Str, Name => Str])
1434              
1435             Each argument is described in detail in: L<Paws::Organizations::UpdatePolicy>
1436              
1437             Returns: a L<Paws::Organizations::UpdatePolicyResponse> instance
1438              
1439             Updates an existing policy with a new name, description, or content. If
1440             any parameter is not supplied, that value remains unchanged. Note that
1441             you cannot change a policy's type.
1442              
1443             This operation can be called only from the organization's master
1444             account.
1445              
1446              
1447              
1448              
1449             =head1 PAGINATORS
1450              
1451             Paginator methods are helpers that repetively call methods that return partial results
1452              
1453             =head2 ListAllAccounts(sub { },[MaxResults => Int, NextToken => Str])
1454              
1455             =head2 ListAllAccounts([MaxResults => Int, NextToken => Str])
1456              
1457              
1458             If passed a sub as first parameter, it will call the sub for each element found in :
1459              
1460             - Accounts, passing the object as the first parameter, and the string 'Accounts' as the second parameter
1461              
1462             If not, it will return a a L<Paws::Organizations::ListAccountsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1463              
1464              
1465             =head2 ListAllAccountsForParent(sub { },ParentId => Str, [MaxResults => Int, NextToken => Str])
1466              
1467             =head2 ListAllAccountsForParent(ParentId => Str, [MaxResults => Int, NextToken => Str])
1468              
1469              
1470             If passed a sub as first parameter, it will call the sub for each element found in :
1471              
1472             - Accounts, passing the object as the first parameter, and the string 'Accounts' as the second parameter
1473              
1474             If not, it will return a a L<Paws::Organizations::ListAccountsForParentResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1475              
1476              
1477             =head2 ListAllChildren(sub { },ChildType => Str, ParentId => Str, [MaxResults => Int, NextToken => Str])
1478              
1479             =head2 ListAllChildren(ChildType => Str, ParentId => Str, [MaxResults => Int, NextToken => Str])
1480              
1481              
1482             If passed a sub as first parameter, it will call the sub for each element found in :
1483              
1484             - Children, passing the object as the first parameter, and the string 'Children' as the second parameter
1485              
1486             If not, it will return a a L<Paws::Organizations::ListChildrenResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1487              
1488              
1489             =head2 ListAllCreateAccountStatus(sub { },[MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef]])
1490              
1491             =head2 ListAllCreateAccountStatus([MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef]])
1492              
1493              
1494             If passed a sub as first parameter, it will call the sub for each element found in :
1495              
1496             - CreateAccountStatuses, passing the object as the first parameter, and the string 'CreateAccountStatuses' as the second parameter
1497              
1498             If not, it will return a a L<Paws::Organizations::ListCreateAccountStatusResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1499              
1500              
1501             =head2 ListAllHandshakesForAccount(sub { },[Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
1502              
1503             =head2 ListAllHandshakesForAccount([Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
1504              
1505              
1506             If passed a sub as first parameter, it will call the sub for each element found in :
1507              
1508             - Handshakes, passing the object as the first parameter, and the string 'Handshakes' as the second parameter
1509              
1510             If not, it will return a a L<Paws::Organizations::ListHandshakesForAccountResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1511              
1512              
1513             =head2 ListAllHandshakesForOrganization(sub { },[Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
1514              
1515             =head2 ListAllHandshakesForOrganization([Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
1516              
1517              
1518             If passed a sub as first parameter, it will call the sub for each element found in :
1519              
1520             - Handshakes, passing the object as the first parameter, and the string 'Handshakes' as the second parameter
1521              
1522             If not, it will return a a L<Paws::Organizations::ListHandshakesForOrganizationResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1523              
1524              
1525             =head2 ListAllOrganizationalUnitsForParent(sub { },ParentId => Str, [MaxResults => Int, NextToken => Str])
1526              
1527             =head2 ListAllOrganizationalUnitsForParent(ParentId => Str, [MaxResults => Int, NextToken => Str])
1528              
1529              
1530             If passed a sub as first parameter, it will call the sub for each element found in :
1531              
1532             - OrganizationalUnits, passing the object as the first parameter, and the string 'OrganizationalUnits' as the second parameter
1533              
1534             If not, it will return a a L<Paws::Organizations::ListOrganizationalUnitsForParentResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1535              
1536              
1537             =head2 ListAllParents(sub { },ChildId => Str, [MaxResults => Int, NextToken => Str])
1538              
1539             =head2 ListAllParents(ChildId => Str, [MaxResults => Int, NextToken => Str])
1540              
1541              
1542             If passed a sub as first parameter, it will call the sub for each element found in :
1543              
1544             - Parents, passing the object as the first parameter, and the string 'Parents' as the second parameter
1545              
1546             If not, it will return a a L<Paws::Organizations::ListParentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1547              
1548              
1549             =head2 ListAllPolicies(sub { },Filter => Str, [MaxResults => Int, NextToken => Str])
1550              
1551             =head2 ListAllPolicies(Filter => Str, [MaxResults => Int, NextToken => Str])
1552              
1553              
1554             If passed a sub as first parameter, it will call the sub for each element found in :
1555              
1556             - Policies, passing the object as the first parameter, and the string 'Policies' as the second parameter
1557              
1558             If not, it will return a a L<Paws::Organizations::ListPoliciesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1559              
1560              
1561             =head2 ListAllPoliciesForTarget(sub { },Filter => Str, TargetId => Str, [MaxResults => Int, NextToken => Str])
1562              
1563             =head2 ListAllPoliciesForTarget(Filter => Str, TargetId => Str, [MaxResults => Int, NextToken => Str])
1564              
1565              
1566             If passed a sub as first parameter, it will call the sub for each element found in :
1567              
1568             - Policies, passing the object as the first parameter, and the string 'Policies' as the second parameter
1569              
1570             If not, it will return a a L<Paws::Organizations::ListPoliciesForTargetResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1571              
1572              
1573             =head2 ListAllRoots(sub { },[MaxResults => Int, NextToken => Str])
1574              
1575             =head2 ListAllRoots([MaxResults => Int, NextToken => Str])
1576              
1577              
1578             If passed a sub as first parameter, it will call the sub for each element found in :
1579              
1580             - Roots, passing the object as the first parameter, and the string 'Roots' as the second parameter
1581              
1582             If not, it will return a a L<Paws::Organizations::ListRootsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1583              
1584              
1585             =head2 ListAllTargetsForPolicy(sub { },PolicyId => Str, [MaxResults => Int, NextToken => Str])
1586              
1587             =head2 ListAllTargetsForPolicy(PolicyId => Str, [MaxResults => Int, NextToken => Str])
1588              
1589              
1590             If passed a sub as first parameter, it will call the sub for each element found in :
1591              
1592             - Targets, passing the object as the first parameter, and the string 'Targets' as the second parameter
1593              
1594             If not, it will return a a L<Paws::Organizations::ListTargetsForPolicyResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1595              
1596              
1597              
1598              
1599              
1600             =head1 SEE ALSO
1601              
1602             This service class forms part of L<Paws>
1603              
1604             =head1 BUGS and CONTRIBUTIONS
1605              
1606             The source code is located here: https://github.com/pplu/aws-sdk-perl
1607              
1608             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
1609              
1610             =cut
1611