blib/lib/Paws/Organizations.pm untested

filter: Statementstmt 0.0% 0 / 490 Branchbran 0.0% 0 / 64 Conditioncond 0.0% 0 / 6 MC/DCmcdc 0.0% 0 / 3 Subroutinesub 0.0% 0 / 74 Podpod 0.0% 0 / 73 totaltotal 0.0% 0 / 710 CC 33 SCAR 18.8
CC
33
Cov
0%
ListAllAccounts
12.0
ListAllAccountsForParent
12.0
ListAllAWSServiceAccessForOrganization
12.0
CRAP 6.5
1 package Paws::Organizations;
2 use Moose;
3 sub service { 'organizations' }
4 sub signing_name { 'organizations' }
5 sub version { '2016-11-28' }
6 sub target_prefix { 'AWSOrganizationsV20161128' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 sub { defined $_[0]->http_status and $_[0]->http_status == 400 and $_[0]->code eq 'TooManyRequestsException' },
14 ] });
15  
16 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
17  
18
19 sub AcceptHandshake {
20 my $self = shift;
21 my $call_object = $self->new_with_coercions('Paws::Organizations::AcceptHandshake', @_);
22 return $self->caller->do_call($self, $call_object);
23 }
24 sub AttachPolicy {
25 my $self = shift;
26 my $call_object = $self->new_with_coercions('Paws::Organizations::AttachPolicy', @_);
27 return $self->caller->do_call($self, $call_object);
28 }
29 sub CancelHandshake {
30 my $self = shift;
31 my $call_object = $self->new_with_coercions('Paws::Organizations::CancelHandshake', @_);
32 return $self->caller->do_call($self, $call_object);
33 }
34 sub CreateAccount {
35 my $self = shift;
36 my $call_object = $self->new_with_coercions('Paws::Organizations::CreateAccount', @_);
37 return $self->caller->do_call($self, $call_object);
38 }
39 sub CreateGovCloudAccount {
40 my $self = shift;
41 my $call_object = $self->new_with_coercions('Paws::Organizations::CreateGovCloudAccount', @_);
42 return $self->caller->do_call($self, $call_object);
43 }
44 sub CreateOrganization {
45 my $self = shift;
46 my $call_object = $self->new_with_coercions('Paws::Organizations::CreateOrganization', @_);
47 return $self->caller->do_call($self, $call_object);
48 }
49 sub CreateOrganizationalUnit {
50 my $self = shift;
51 my $call_object = $self->new_with_coercions('Paws::Organizations::CreateOrganizationalUnit', @_);
52 return $self->caller->do_call($self, $call_object);
53 }
54 sub CreatePolicy {
55 my $self = shift;
56 my $call_object = $self->new_with_coercions('Paws::Organizations::CreatePolicy', @_);
57 return $self->caller->do_call($self, $call_object);
58 }
59 sub DeclineHandshake {
60 my $self = shift;
61 my $call_object = $self->new_with_coercions('Paws::Organizations::DeclineHandshake', @_);
62 return $self->caller->do_call($self, $call_object);
63 }
64 sub DeleteOrganization {
65 my $self = shift;
66 my $call_object = $self->new_with_coercions('Paws::Organizations::DeleteOrganization', @_);
67 return $self->caller->do_call($self, $call_object);
68 }
69 sub DeleteOrganizationalUnit {
70 my $self = shift;
71 my $call_object = $self->new_with_coercions('Paws::Organizations::DeleteOrganizationalUnit', @_);
72 return $self->caller->do_call($self, $call_object);
73 }
74 sub DeletePolicy {
75 my $self = shift;
76 my $call_object = $self->new_with_coercions('Paws::Organizations::DeletePolicy', @_);
77 return $self->caller->do_call($self, $call_object);
78 }
79 sub DeregisterDelegatedAdministrator {
80 my $self = shift;
81 my $call_object = $self->new_with_coercions('Paws::Organizations::DeregisterDelegatedAdministrator', @_);
82 return $self->caller->do_call($self, $call_object);
83 }
84 sub DescribeAccount {
85 my $self = shift;
86 my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeAccount', @_);
87 return $self->caller->do_call($self, $call_object);
88 }
89 sub DescribeCreateAccountStatus {
90 my $self = shift;
91 my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeCreateAccountStatus', @_);
92 return $self->caller->do_call($self, $call_object);
93 }
94 sub DescribeEffectivePolicy {
95 my $self = shift;
96 my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeEffectivePolicy', @_);
97 return $self->caller->do_call($self, $call_object);
98 }
99 sub DescribeHandshake {
100 my $self = shift;
101 my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeHandshake', @_);
102 return $self->caller->do_call($self, $call_object);
103 }
104 sub DescribeOrganization {
105 my $self = shift;
106 my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeOrganization', @_);
107 return $self->caller->do_call($self, $call_object);
108 }
109 sub DescribeOrganizationalUnit {
110 my $self = shift;
111 my $call_object = $self->new_with_coercions('Paws::Organizations::DescribeOrganizationalUnit', @_);
112 return $self->caller->do_call($self, $call_object);
113 }
114 sub DescribePolicy {
115 my $self = shift;
116 my $call_object = $self->new_with_coercions('Paws::Organizations::DescribePolicy', @_);
117 return $self->caller->do_call($self, $call_object);
118 }
119 sub DetachPolicy {
120 my $self = shift;
121 my $call_object = $self->new_with_coercions('Paws::Organizations::DetachPolicy', @_);
122 return $self->caller->do_call($self, $call_object);
123 }
124 sub DisableAWSServiceAccess {
125 my $self = shift;
126 my $call_object = $self->new_with_coercions('Paws::Organizations::DisableAWSServiceAccess', @_);
127 return $self->caller->do_call($self, $call_object);
128 }
129 sub DisablePolicyType {
130 my $self = shift;
131 my $call_object = $self->new_with_coercions('Paws::Organizations::DisablePolicyType', @_);
132 return $self->caller->do_call($self, $call_object);
133 }
134 sub EnableAllFeatures {
135 my $self = shift;
136 my $call_object = $self->new_with_coercions('Paws::Organizations::EnableAllFeatures', @_);
137 return $self->caller->do_call($self, $call_object);
138 }
139 sub EnableAWSServiceAccess {
140 my $self = shift;
141 my $call_object = $self->new_with_coercions('Paws::Organizations::EnableAWSServiceAccess', @_);
142 return $self->caller->do_call($self, $call_object);
143 }
144 sub EnablePolicyType {
145 my $self = shift;
146 my $call_object = $self->new_with_coercions('Paws::Organizations::EnablePolicyType', @_);
147 return $self->caller->do_call($self, $call_object);
148 }
149 sub InviteAccountToOrganization {
150 my $self = shift;
151 my $call_object = $self->new_with_coercions('Paws::Organizations::InviteAccountToOrganization', @_);
152 return $self->caller->do_call($self, $call_object);
153 }
154 sub LeaveOrganization {
155 my $self = shift;
156 my $call_object = $self->new_with_coercions('Paws::Organizations::LeaveOrganization', @_);
157 return $self->caller->do_call($self, $call_object);
158 }
159 sub ListAccounts {
160 my $self = shift;
161 my $call_object = $self->new_with_coercions('Paws::Organizations::ListAccounts', @_);
162 return $self->caller->do_call($self, $call_object);
163 }
164 sub ListAccountsForParent {
165 my $self = shift;
166 my $call_object = $self->new_with_coercions('Paws::Organizations::ListAccountsForParent', @_);
167 return $self->caller->do_call($self, $call_object);
168 }
169 sub ListAWSServiceAccessForOrganization {
170 my $self = shift;
171 my $call_object = $self->new_with_coercions('Paws::Organizations::ListAWSServiceAccessForOrganization', @_);
172 return $self->caller->do_call($self, $call_object);
173 }
174 sub ListChildren {
175 my $self = shift;
176 my $call_object = $self->new_with_coercions('Paws::Organizations::ListChildren', @_);
177 return $self->caller->do_call($self, $call_object);
178 }
179 sub ListCreateAccountStatus {
180 my $self = shift;
181 my $call_object = $self->new_with_coercions('Paws::Organizations::ListCreateAccountStatus', @_);
182 return $self->caller->do_call($self, $call_object);
183 }
184 sub ListDelegatedAdministrators {
185 my $self = shift;
186 my $call_object = $self->new_with_coercions('Paws::Organizations::ListDelegatedAdministrators', @_);
187 return $self->caller->do_call($self, $call_object);
188 }
189 sub ListDelegatedServicesForAccount {
190 my $self = shift;
191 my $call_object = $self->new_with_coercions('Paws::Organizations::ListDelegatedServicesForAccount', @_);
192 return $self->caller->do_call($self, $call_object);
193 }
194 sub ListHandshakesForAccount {
195 my $self = shift;
196 my $call_object = $self->new_with_coercions('Paws::Organizations::ListHandshakesForAccount', @_);
197 return $self->caller->do_call($self, $call_object);
198 }
199 sub ListHandshakesForOrganization {
200 my $self = shift;
201 my $call_object = $self->new_with_coercions('Paws::Organizations::ListHandshakesForOrganization', @_);
202 return $self->caller->do_call($self, $call_object);
203 }
204 sub ListOrganizationalUnitsForParent {
205 my $self = shift;
206 my $call_object = $self->new_with_coercions('Paws::Organizations::ListOrganizationalUnitsForParent', @_);
207 return $self->caller->do_call($self, $call_object);
208 }
209 sub ListParents {
210 my $self = shift;
211 my $call_object = $self->new_with_coercions('Paws::Organizations::ListParents', @_);
212 return $self->caller->do_call($self, $call_object);
213 }
214 sub ListPolicies {
215 my $self = shift;
216 my $call_object = $self->new_with_coercions('Paws::Organizations::ListPolicies', @_);
217 return $self->caller->do_call($self, $call_object);
218 }
219 sub ListPoliciesForTarget {
220 my $self = shift;
221 my $call_object = $self->new_with_coercions('Paws::Organizations::ListPoliciesForTarget', @_);
222 return $self->caller->do_call($self, $call_object);
223 }
224 sub ListRoots {
225 my $self = shift;
226 my $call_object = $self->new_with_coercions('Paws::Organizations::ListRoots', @_);
227 return $self->caller->do_call($self, $call_object);
228 }
229 sub ListTagsForResource {
230 my $self = shift;
231 my $call_object = $self->new_with_coercions('Paws::Organizations::ListTagsForResource', @_);
232 return $self->caller->do_call($self, $call_object);
233 }
234 sub ListTargetsForPolicy {
235 my $self = shift;
236 my $call_object = $self->new_with_coercions('Paws::Organizations::ListTargetsForPolicy', @_);
237 return $self->caller->do_call($self, $call_object);
238 }
239 sub MoveAccount {
240 my $self = shift;
241 my $call_object = $self->new_with_coercions('Paws::Organizations::MoveAccount', @_);
242 return $self->caller->do_call($self, $call_object);
243 }
244 sub RegisterDelegatedAdministrator {
245 my $self = shift;
246 my $call_object = $self->new_with_coercions('Paws::Organizations::RegisterDelegatedAdministrator', @_);
247 return $self->caller->do_call($self, $call_object);
248 }
249 sub RemoveAccountFromOrganization {
250 my $self = shift;
251 my $call_object = $self->new_with_coercions('Paws::Organizations::RemoveAccountFromOrganization', @_);
252 return $self->caller->do_call($self, $call_object);
253 }
254 sub TagResource {
255 my $self = shift;
256 my $call_object = $self->new_with_coercions('Paws::Organizations::TagResource', @_);
257 return $self->caller->do_call($self, $call_object);
258 }
259 sub UntagResource {
260 my $self = shift;
261 my $call_object = $self->new_with_coercions('Paws::Organizations::UntagResource', @_);
262 return $self->caller->do_call($self, $call_object);
263 }
264 sub UpdateOrganizationalUnit {
265 my $self = shift;
266 my $call_object = $self->new_with_coercions('Paws::Organizations::UpdateOrganizationalUnit', @_);
267 return $self->caller->do_call($self, $call_object);
268 }
269 sub UpdatePolicy {
270 my $self = shift;
271 my $call_object = $self->new_with_coercions('Paws::Organizations::UpdatePolicy', @_);
272 return $self->caller->do_call($self, $call_object);
273 }
274
275 sub ListAllAccounts {
276 my $self = shift;
277  
278 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
279 my $result = $self->ListAccounts(@_);
280 my $next_result = $result;
281  
282 if (not defined $callback) {
283 while ($next_result->NextToken) {
284 $next_result = $self->ListAccounts(@_, NextToken => $next_result->NextToken);
285 push @{ $result->Accounts }, @{ $next_result->Accounts };
286 }
287 return $result;
288 } else {
289 while ($result->NextToken) {
290 $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
291 $result = $self->ListAccounts(@_, NextToken => $result->NextToken);
292 }
293 $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
294 }
295  
296 return undef
297 }
298 sub ListAllAccountsForParent {
299 my $self = shift;
300  
301 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
302 my $result = $self->ListAccountsForParent(@_);
303 my $next_result = $result;
304  
305 if (not defined $callback) {
306 while ($next_result->NextToken) {
307 $next_result = $self->ListAccountsForParent(@_, NextToken => $next_result->NextToken);
308 push @{ $result->Accounts }, @{ $next_result->Accounts };
309 }
310 return $result;
311 } else {
312 while ($result->NextToken) {
313 $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
314 $result = $self->ListAccountsForParent(@_, NextToken => $result->NextToken);
315 }
316 $callback->($_ => 'Accounts') foreach (@{ $result->Accounts });
317 }
318  
319 return undef
320 }
321 sub ListAllAWSServiceAccessForOrganization {
322 my $self = shift;
323  
324 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
325 my $result = $self->ListAWSServiceAccessForOrganization(@_);
326 my $next_result = $result;
327  
328 if (not defined $callback) {
329 while ($next_result->NextToken) {
330 $next_result = $self->ListAWSServiceAccessForOrganization(@_, NextToken => $next_result->NextToken);
331 push @{ $result->EnabledServicePrincipals }, @{ $next_result->EnabledServicePrincipals };
332 }
333 return $result;
334 } else {
335 while ($result->NextToken) {
336 $callback->($_ => 'EnabledServicePrincipals') foreach (@{ $result->EnabledServicePrincipals });
337 $result = $self->ListAWSServiceAccessForOrganization(@_, NextToken => $result->NextToken);
338 }
339 $callback->($_ => 'EnabledServicePrincipals') foreach (@{ $result->EnabledServicePrincipals });
340 }
341  
342 return undef
343 }
344 sub ListAllChildren {
345 my $self = shift;
346  
347 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
348 my $result = $self->ListChildren(@_);
349 my $next_result = $result;
350  
351 if (not defined $callback) {
352 while ($next_result->NextToken) {
353 $next_result = $self->ListChildren(@_, NextToken => $next_result->NextToken);
354 push @{ $result->Children }, @{ $next_result->Children };
355 }
356 return $result;
357 } else {
358 while ($result->NextToken) {
359 $callback->($_ => 'Children') foreach (@{ $result->Children });
360 $result = $self->ListChildren(@_, NextToken => $result->NextToken);
361 }
362 $callback->($_ => 'Children') foreach (@{ $result->Children });
363 }
364  
365 return undef
366 }
367 sub ListAllCreateAccountStatus {
368 my $self = shift;
369  
370 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
371 my $result = $self->ListCreateAccountStatus(@_);
372 my $next_result = $result;
373  
374 if (not defined $callback) {
375 while ($next_result->NextToken) {
376 $next_result = $self->ListCreateAccountStatus(@_, NextToken => $next_result->NextToken);
377 push @{ $result->CreateAccountStatuses }, @{ $next_result->CreateAccountStatuses };
378 }
379 return $result;
380 } else {
381 while ($result->NextToken) {
382 $callback->($_ => 'CreateAccountStatuses') foreach (@{ $result->CreateAccountStatuses });
383 $result = $self->ListCreateAccountStatus(@_, NextToken => $result->NextToken);
384 }
385 $callback->($_ => 'CreateAccountStatuses') foreach (@{ $result->CreateAccountStatuses });
386 }
387  
388 return undef
389 }
390 sub ListAllDelegatedAdministrators {
391 my $self = shift;
392  
393 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
394 my $result = $self->ListDelegatedAdministrators(@_);
395 my $next_result = $result;
396  
397 if (not defined $callback) {
398 while ($next_result->NextToken) {
399 $next_result = $self->ListDelegatedAdministrators(@_, NextToken => $next_result->NextToken);
400 push @{ $result->DelegatedAdministrators }, @{ $next_result->DelegatedAdministrators };
401 }
402 return $result;
403 } else {
404 while ($result->NextToken) {
405 $callback->($_ => 'DelegatedAdministrators') foreach (@{ $result->DelegatedAdministrators });
406 $result = $self->ListDelegatedAdministrators(@_, NextToken => $result->NextToken);
407 }
408 $callback->($_ => 'DelegatedAdministrators') foreach (@{ $result->DelegatedAdministrators });
409 }
410  
411 return undef
412 }
413 sub ListAllDelegatedServicesForAccount {
414 my $self = shift;
415  
416 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
417 my $result = $self->ListDelegatedServicesForAccount(@_);
418 my $next_result = $result;
419  
420 if (not defined $callback) {
421 while ($next_result->NextToken) {
422 $next_result = $self->ListDelegatedServicesForAccount(@_, NextToken => $next_result->NextToken);
423 push @{ $result->DelegatedServices }, @{ $next_result->DelegatedServices };
424 }
425 return $result;
426 } else {
427 while ($result->NextToken) {
428 $callback->($_ => 'DelegatedServices') foreach (@{ $result->DelegatedServices });
429 $result = $self->ListDelegatedServicesForAccount(@_, NextToken => $result->NextToken);
430 }
431 $callback->($_ => 'DelegatedServices') foreach (@{ $result->DelegatedServices });
432 }
433  
434 return undef
435 }
436 sub ListAllHandshakesForAccount {
437 my $self = shift;
438  
439 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
440 my $result = $self->ListHandshakesForAccount(@_);
441 my $next_result = $result;
442  
443 if (not defined $callback) {
444 while ($next_result->NextToken) {
445 $next_result = $self->ListHandshakesForAccount(@_, NextToken => $next_result->NextToken);
446 push @{ $result->Handshakes }, @{ $next_result->Handshakes };
447 }
448 return $result;
449 } else {
450 while ($result->NextToken) {
451 $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
452 $result = $self->ListHandshakesForAccount(@_, NextToken => $result->NextToken);
453 }
454 $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
455 }
456  
457 return undef
458 }
459 sub ListAllHandshakesForOrganization {
460 my $self = shift;
461  
462 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
463 my $result = $self->ListHandshakesForOrganization(@_);
464 my $next_result = $result;
465  
466 if (not defined $callback) {
467 while ($next_result->NextToken) {
468 $next_result = $self->ListHandshakesForOrganization(@_, NextToken => $next_result->NextToken);
469 push @{ $result->Handshakes }, @{ $next_result->Handshakes };
470 }
471 return $result;
472 } else {
473 while ($result->NextToken) {
474 $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
475 $result = $self->ListHandshakesForOrganization(@_, NextToken => $result->NextToken);
476 }
477 $callback->($_ => 'Handshakes') foreach (@{ $result->Handshakes });
478 }
479  
480 return undef
481 }
482 sub ListAllOrganizationalUnitsForParent {
483 my $self = shift;
484  
485 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
486 my $result = $self->ListOrganizationalUnitsForParent(@_);
487 my $next_result = $result;
488  
489 if (not defined $callback) {
490 while ($next_result->NextToken) {
491 $next_result = $self->ListOrganizationalUnitsForParent(@_, NextToken => $next_result->NextToken);
492 push @{ $result->OrganizationalUnits }, @{ $next_result->OrganizationalUnits };
493 }
494 return $result;
495 } else {
496 while ($result->NextToken) {
497 $callback->($_ => 'OrganizationalUnits') foreach (@{ $result->OrganizationalUnits });
498 $result = $self->ListOrganizationalUnitsForParent(@_, NextToken => $result->NextToken);
499 }
500 $callback->($_ => 'OrganizationalUnits') foreach (@{ $result->OrganizationalUnits });
501 }
502  
503 return undef
504 }
505 sub ListAllParents {
506 my $self = shift;
507  
508 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
509 my $result = $self->ListParents(@_);
510 my $next_result = $result;
511  
512 if (not defined $callback) {
513 while ($next_result->NextToken) {
514 $next_result = $self->ListParents(@_, NextToken => $next_result->NextToken);
515 push @{ $result->Parents }, @{ $next_result->Parents };
516 }
517 return $result;
518 } else {
519 while ($result->NextToken) {
520 $callback->($_ => 'Parents') foreach (@{ $result->Parents });
521 $result = $self->ListParents(@_, NextToken => $result->NextToken);
522 }
523 $callback->($_ => 'Parents') foreach (@{ $result->Parents });
524 }
525  
526 return undef
527 }
528 sub ListAllPolicies {
529 my $self = shift;
530  
531 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
532 my $result = $self->ListPolicies(@_);
533 my $next_result = $result;
534  
535 if (not defined $callback) {
536 while ($next_result->NextToken) {
537 $next_result = $self->ListPolicies(@_, NextToken => $next_result->NextToken);
538 push @{ $result->Policies }, @{ $next_result->Policies };
539 }
540 return $result;
541 } else {
542 while ($result->NextToken) {
543 $callback->($_ => 'Policies') foreach (@{ $result->Policies });
544 $result = $self->ListPolicies(@_, NextToken => $result->NextToken);
545 }
546 $callback->($_ => 'Policies') foreach (@{ $result->Policies });
547 }
548  
549 return undef
550 }
551 sub ListAllPoliciesForTarget {
552 my $self = shift;
553  
554 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
555 my $result = $self->ListPoliciesForTarget(@_);
556 my $next_result = $result;
557  
558 if (not defined $callback) {
559 while ($next_result->NextToken) {
560 $next_result = $self->ListPoliciesForTarget(@_, NextToken => $next_result->NextToken);
561 push @{ $result->Policies }, @{ $next_result->Policies };
562 }
563 return $result;
564 } else {
565 while ($result->NextToken) {
566 $callback->($_ => 'Policies') foreach (@{ $result->Policies });
567 $result = $self->ListPoliciesForTarget(@_, NextToken => $result->NextToken);
568 }
569 $callback->($_ => 'Policies') foreach (@{ $result->Policies });
570 }
571  
572 return undef
573 }
574 sub ListAllRoots {
575 my $self = shift;
576  
577 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
578 my $result = $self->ListRoots(@_);
579 my $next_result = $result;
580  
581 if (not defined $callback) {
582 while ($next_result->NextToken) {
583 $next_result = $self->ListRoots(@_, NextToken => $next_result->NextToken);
584 push @{ $result->Roots }, @{ $next_result->Roots };
585 }
586 return $result;
587 } else {
588 while ($result->NextToken) {
589 $callback->($_ => 'Roots') foreach (@{ $result->Roots });
590 $result = $self->ListRoots(@_, NextToken => $result->NextToken);
591 }
592 $callback->($_ => 'Roots') foreach (@{ $result->Roots });
593 }
594  
595 return undef
596 }
597 sub ListAllTagsForResource {
598 my $self = shift;
599  
600 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
601 my $result = $self->ListTagsForResource(@_);
602 my $next_result = $result;
603  
604 if (not defined $callback) {
605 while ($next_result->NextToken) {
606 $next_result = $self->ListTagsForResource(@_, NextToken => $next_result->NextToken);
607 push @{ $result->Tags }, @{ $next_result->Tags };
608 }
609 return $result;
610 } else {
611 while ($result->NextToken) {
612 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
613 $result = $self->ListTagsForResource(@_, NextToken => $result->NextToken);
614 }
615 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
616 }
617  
618 return undef
619 }
620 sub ListAllTargetsForPolicy {
621 my $self = shift;
622  
623 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
624 my $result = $self->ListTargetsForPolicy(@_);
625 my $next_result = $result;
626  
627 if (not defined $callback) {
628 while ($next_result->NextToken) {
629 $next_result = $self->ListTargetsForPolicy(@_, NextToken => $next_result->NextToken);
630 push @{ $result->Targets }, @{ $next_result->Targets };
631 }
632 return $result;
633 } else {
634 while ($result->NextToken) {
635 $callback->($_ => 'Targets') foreach (@{ $result->Targets });
636 $result = $self->ListTargetsForPolicy(@_, NextToken => $result->NextToken);
637 }
638 $callback->($_ => 'Targets') foreach (@{ $result->Targets });
639 }
640  
641 return undef
642 }
643  
644  
645 sub operations { qw/AcceptHandshake AttachPolicy CancelHandshake CreateAccount CreateGovCloudAccount CreateOrganization CreateOrganizationalUnit CreatePolicy DeclineHandshake DeleteOrganization DeleteOrganizationalUnit DeletePolicy DeregisterDelegatedAdministrator DescribeAccount DescribeCreateAccountStatus DescribeEffectivePolicy DescribeHandshake DescribeOrganization DescribeOrganizationalUnit DescribePolicy DetachPolicy DisableAWSServiceAccess DisablePolicyType EnableAllFeatures EnableAWSServiceAccess EnablePolicyType InviteAccountToOrganization LeaveOrganization ListAccounts ListAccountsForParent ListAWSServiceAccessForOrganization ListChildren ListCreateAccountStatus ListDelegatedAdministrators ListDelegatedServicesForAccount ListHandshakesForAccount ListHandshakesForOrganization ListOrganizationalUnitsForParent ListParents ListPolicies ListPoliciesForTarget ListRoots ListTagsForResource ListTargetsForPolicy MoveAccount RegisterDelegatedAdministrator RemoveAccountFromOrganization TagResource UntagResource UpdateOrganizationalUnit UpdatePolicy / }
646  
647 1;
648  
649 ### main pod documentation begin ###
650  
651 =head1 NAME
652  
653 Paws::Organizations - Perl Interface to AWS AWS Organizations
654  
655 =head1 SYNOPSIS
656  
657 use Paws;
658  
659 my $obj = Paws->service('Organizations');
660 my $res = $obj->Method(
661 Arg1 => $val1,
662 Arg2 => [ 'V1', 'V2' ],
663 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
664 # of the arguments type
665 Arg3 => { Att1 => 'Val1' },
666 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
667 # the constructor of the arguments type
668 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
669 );
670  
671 =head1 DESCRIPTION
672  
673 AWS Organizations is a web service that enables you to consolidate your
674 multiple AWS accounts into an I<organization> and centrally manage your
675 accounts and their resources.
676  
677 This guide provides descriptions of the Organizations operations. For
678 more information about using this service, see the AWS Organizations
679 User Guide
680 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html).
681  
682 B<Support and feedback for AWS Organizations>
683  
684 We welcome your feedback. Send your comments to
685 feedback-awsorganizations@amazon.com
686 (mailto:feedback-awsorganizations@amazon.com) or post your feedback and
687 questions in the AWS Organizations support forum
688 (http://forums.aws.amazon.com/forum.jspa?forumID=219). For more
689 information about the AWS support forums, see Forums Help
690 (http://forums.aws.amazon.com/help.jspa).
691  
692 B<Endpoint to call When using the AWS CLI or the AWS SDK>
693  
694 For the current release of Organizations, specify the C<us-east-1>
695 region for all AWS API and AWS CLI calls made from the commercial AWS
696 Regions outside of China. If calling from one of the AWS Regions in
697 China, then specify C<cn-northwest-1>. You can do this in the AWS CLI
698 by using these parameters and commands:
699  
700 =over
701  
702 =item *
703  
704 Use the following parameter with each command to specify both the
705 endpoint and its region:
706  
707 C<--endpoint-url https://organizations.us-east-1.amazonaws.com> I<(from
708 commercial AWS Regions outside of China)>
709  
710 or
711  
712 C<--endpoint-url https://organizations.cn-northwest-1.amazonaws.com.cn>
713 I<(from AWS Regions in China)>
714  
715 =item *
716  
717 Use the default endpoint, but configure your default region with this
718 command:
719  
720 C<aws configure set default.region us-east-1> I<(from commercial AWS
721 Regions outside of China)>
722  
723 or
724  
725 C<aws configure set default.region cn-northwest-1> I<(from AWS Regions
726 in China)>
727  
728 =item *
729  
730 Use the following parameter with each command to specify the endpoint:
731  
732 C<--region us-east-1> I<(from commercial AWS Regions outside of China)>
733  
734 or
735  
736 C<--region cn-northwest-1> I<(from AWS Regions in China)>
737  
738 =back
739  
740 B<Recording API Requests>
741  
742 AWS Organizations supports AWS CloudTrail, a service that records AWS
743 API calls for your AWS account and delivers log files to an Amazon S3
744 bucket. By using information collected by AWS CloudTrail, you can
745 determine which requests the Organizations service received, who made
746 the request and when, and so on. For more about AWS Organizations and
747 its support for AWS CloudTrail, see Logging AWS Organizations Events
748 with AWS CloudTrail
749 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_incident-response.html#orgs_cloudtrail-integration)
750 in the I<AWS Organizations User Guide>. To learn more about AWS
751 CloudTrail, including how to turn it on and find your log files, see
752 the AWS CloudTrail User Guide
753 (http://docs.aws.amazon.com/awscloudtrail/latest/userguide/what_is_cloud_trail_top_level.html).
754  
755 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/organizations-2016-11-28>
756  
757  
758 =head1 METHODS
759  
760 =head2 AcceptHandshake
761  
762 =over
763  
764 =item HandshakeId => Str
765  
766  
767 =back
768  
769 Each argument is described in detail in: L<Paws::Organizations::AcceptHandshake>
770  
771 Returns: a L<Paws::Organizations::AcceptHandshakeResponse> instance
772  
773 Sends a response to the originator of a handshake agreeing to the
774 action proposed by the handshake request.
775  
776 This operation can be called only by the following principals when they
777 also have the relevant IAM permissions:
778  
779 =over
780  
781 =item *
782  
783 B<Invitation to join> or B<Approve all features request> handshakes:
784 only a principal from the member account.
785  
786 The user who calls the API for an invitation to join must have the
787 C<organizations:AcceptHandshake> permission. If you enabled all
788 features in the organization, the user must also have the
789 C<iam:CreateServiceLinkedRole> permission so that AWS Organizations can
790 create the required service-linked role named
791 C<AWSServiceRoleForOrganizations>. For more information, see AWS
792 Organizations and Service-Linked Roles
793 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_integration_services.html#orgs_integration_service-linked-roles)
794 in the I<AWS Organizations User Guide>.
795  
796 =item *
797  
798 B<Enable all features final confirmation> handshake: only a principal
799 from the management account.
800  
801 For more information about invitations, see Inviting an AWS Account to
802 Join Your Organization
803 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_invites.html)
804 in the I<AWS Organizations User Guide.> For more information about
805 requests to enable all features in the organization, see Enabling All
806 Features in Your Organization
807 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html)
808 in the I<AWS Organizations User Guide.>
809  
810 =back
811  
812 After you accept a handshake, it continues to appear in the results of
813 relevant APIs for only 30 days. After that, it's deleted.
814  
815  
816 =head2 AttachPolicy
817  
818 =over
819  
820 =item PolicyId => Str
821  
822 =item TargetId => Str
823  
824  
825 =back
826  
827 Each argument is described in detail in: L<Paws::Organizations::AttachPolicy>
828  
829 Returns: nothing
830  
831 Attaches a policy to a root, an organizational unit (OU), or an
832 individual account. How the policy affects accounts depends on the type
833 of policy. Refer to the I<AWS Organizations User Guide> for information
834 about each policy type:
835  
836 =over
837  
838 =item *
839  
840 AISERVICES_OPT_OUT_POLICY
841 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html)
842  
843 =item *
844  
845 BACKUP_POLICY
846 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_backup.html)
847  
848 =item *
849  
850 SERVICE_CONTROL_POLICY
851 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scp.html)
852  
853 =item *
854  
855 TAG_POLICY
856 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_tag-policies.html)
857  
858 =back
859  
860 This operation can be called only from the organization's management
861 account.
862  
863  
864 =head2 CancelHandshake
865  
866 =over
867  
868 =item HandshakeId => Str
869  
870  
871 =back
872  
873 Each argument is described in detail in: L<Paws::Organizations::CancelHandshake>
874  
875 Returns: a L<Paws::Organizations::CancelHandshakeResponse> instance
876  
877 Cancels a handshake. Canceling a handshake sets the handshake state to
878 C<CANCELED>.
879  
880 This operation can be called only from the account that originated the
881 handshake. The recipient of the handshake can't cancel it, but can use
882 DeclineHandshake instead. After a handshake is canceled, the recipient
883 can no longer respond to that handshake.
884  
885 After you cancel a handshake, it continues to appear in the results of
886 relevant APIs for only 30 days. After that, it's deleted.
887  
888  
889 =head2 CreateAccount
890  
891 =over
892  
893 =item AccountName => Str
894  
895 =item Email => Str
896  
897 =item [IamUserAccessToBilling => Str]
898  
899 =item [RoleName => Str]
900  
901 =item [Tags => ArrayRef[L<Paws::Organizations::Tag>]]
902  
903  
904 =back
905  
906 Each argument is described in detail in: L<Paws::Organizations::CreateAccount>
907  
908 Returns: a L<Paws::Organizations::CreateAccountResponse> instance
909  
910 Creates an AWS account that is automatically a member of the
911 organization whose credentials made the request. This is an
912 asynchronous request that AWS performs in the background. Because
913 C<CreateAccount> operates asynchronously, it can return a successful
914 completion message even though account initialization might still be in
915 progress. You might need to wait a few minutes before you can
916 successfully access the account. To check the status of the request, do
917 one of the following:
918  
919 =over
920  
921 =item *
922  
923 Use the C<Id> member of the C<CreateAccountStatus> response element
924 from this operation to provide as a parameter to the
925 DescribeCreateAccountStatus operation.
926  
927 =item *
928  
929 Check the AWS CloudTrail log for the C<CreateAccountResult> event. For
930 information on using AWS CloudTrail with AWS Organizations, see Logging
931 and monitoring in AWS Organizations
932 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_security_incident-response.html#orgs_cloudtrail-integration)
933 in the I<AWS Organizations User Guide.>
934  
935 =back
936  
937 The user who calls the API to create an account must have the
938 C<organizations:CreateAccount> permission. If you enabled all features
939 in the organization, AWS Organizations creates the required
940 service-linked role named C<AWSServiceRoleForOrganizations>. For more
941 information, see AWS Organizations and Service-Linked Roles
942 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html#orgs_integrate_services-using_slrs)
943 in the I<AWS Organizations User Guide>.
944  
945 If the request includes tags, then the requester must have the
946 C<organizations:TagResource> permission.
947  
948 AWS Organizations preconfigures the new member account with a role
949 (named C<OrganizationAccountAccessRole> by default) that grants users
950 in the management account administrator permissions in the new member
951 account. Principals in the management account can assume the role. AWS
952 Organizations clones the company name and address information for the
953 new account from the organization's management account.
954  
955 This operation can be called only from the organization's management
956 account.
957  
958 For more information about creating accounts, see Creating an AWS
959 Account in Your Organization
960 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_create.html)
961 in the I<AWS Organizations User Guide.>
962  
963 =over
964  
965 =item *
966  
967 When you create an account in an organization using the AWS
968 Organizations console, API, or CLI commands, the information required
969 for the account to operate as a standalone account, such as a payment
970 method and signing the end user license agreement (EULA) is I<not>
971 automatically collected. If you must remove an account from your
972 organization later, you can do so only after you provide the missing
973 information. Follow the steps at To leave an organization as a member
974 account
975 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_remove.html#leave-without-all-info)
976 in the I<AWS Organizations User Guide>.
977  
978 =item *
979  
980 If you get an exception that indicates that you exceeded your account
981 limits for the organization, contact AWS Support
982 (https://console.aws.amazon.com/support/home#/).
983  
984 =item *
985  
986 If you get an exception that indicates that the operation failed
987 because your organization is still initializing, wait one hour and then
988 try again. If the error persists, contact AWS Support
989 (https://console.aws.amazon.com/support/home#/).
990  
991 =item *
992  
993 Using C<CreateAccount> to create multiple temporary accounts isn't
994 recommended. You can only close an account from the Billing and Cost
995 Management Console, and you must be signed in as the root user. For
996 information on the requirements and process for closing an account, see
997 Closing an AWS Account
998 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_close.html)
999 in the I<AWS Organizations User Guide>.
1000  
1001 =back
1002  
1003 When you create a member account with this operation, you can choose
1004 whether to create the account with the B<IAM User and Role Access to
1005 Billing Information> switch enabled. If you enable it, IAM users and
1006 roles that have appropriate permissions can view billing information
1007 for the account. If you disable it, only the account root user can
1008 access billing information. For information about how to disable this
1009 switch for an account, see Granting Access to Your Billing Information
1010 and Tools
1011 (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/grantaccess.html).
1012  
1013  
1014 =head2 CreateGovCloudAccount
1015  
1016 =over
1017  
1018 =item AccountName => Str
1019  
1020 =item Email => Str
1021  
1022 =item [IamUserAccessToBilling => Str]
1023  
1024 =item [RoleName => Str]
1025  
1026 =item [Tags => ArrayRef[L<Paws::Organizations::Tag>]]
1027  
1028  
1029 =back
1030  
1031 Each argument is described in detail in: L<Paws::Organizations::CreateGovCloudAccount>
1032  
1033 Returns: a L<Paws::Organizations::CreateGovCloudAccountResponse> instance
1034  
1035 This action is available if all of the following are true:
1036  
1037 =over
1038  
1039 =item *
1040  
1041 You're authorized to create accounts in the AWS GovCloud (US) Region.
1042 For more information on the AWS GovCloud (US) Region, see the I<AWS
1043 GovCloud User Guide>.
1044 (http://docs.aws.amazon.com/govcloud-us/latest/UserGuide/welcome.html)
1045  
1046 =item *
1047  
1048 You already have an account in the AWS GovCloud (US) Region that is
1049 paired with a management account of an organization in the commercial
1050 Region.
1051  
1052 =item *
1053  
1054 You call this action from the management account of your organization
1055 in the commercial Region.
1056  
1057 =item *
1058  
1059 You have the C<organizations:CreateGovCloudAccount> permission.
1060  
1061 =back
1062  
1063 AWS Organizations automatically creates the required service-linked
1064 role named C<AWSServiceRoleForOrganizations>. For more information, see
1065 AWS Organizations and Service-Linked Roles
1066 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html#orgs_integrate_services-using_slrs)
1067 in the I<AWS Organizations User Guide.>
1068  
1069 AWS automatically enables AWS CloudTrail for AWS GovCloud (US)
1070 accounts, but you should also do the following:
1071  
1072 =over
1073  
1074 =item *
1075  
1076 Verify that AWS CloudTrail is enabled to store logs.
1077  
1078 =item *
1079  
1080 Create an S3 bucket for AWS CloudTrail log storage.
1081  
1082 For more information, see Verifying AWS CloudTrail Is Enabled
1083 (http://docs.aws.amazon.com/govcloud-us/latest/UserGuide/verifying-cloudtrail.html)
1084 in the I<AWS GovCloud User Guide>.
1085  
1086 =back
1087  
1088 If the request includes tags, then the requester must have the
1089 C<organizations:TagResource> permission. The tags are attached to the
1090 commercial account associated with the GovCloud account, rather than
1091 the GovCloud account itself. To add tags to the GovCloud account, call
1092 the TagResource operation in the GovCloud Region after the new GovCloud
1093 account exists.
1094  
1095 You call this action from the management account of your organization
1096 in the commercial Region to create a standalone AWS account in the AWS
1097 GovCloud (US) Region. After the account is created, the management
1098 account of an organization in the AWS GovCloud (US) Region can invite
1099 it to that organization. For more information on inviting standalone
1100 accounts in the AWS GovCloud (US) to join an organization, see AWS
1101 Organizations
1102 (http://docs.aws.amazon.com/govcloud-us/latest/UserGuide/govcloud-organizations.html)
1103 in the I<AWS GovCloud User Guide.>
1104  
1105 Calling C<CreateGovCloudAccount> is an asynchronous request that AWS
1106 performs in the background. Because C<CreateGovCloudAccount> operates
1107 asynchronously, it can return a successful completion message even
1108 though account initialization might still be in progress. You might
1109 need to wait a few minutes before you can successfully access the
1110 account. To check the status of the request, do one of the following:
1111  
1112 =over
1113  
1114 =item *
1115  
1116 Use the C<OperationId> response element from this operation to provide
1117 as a parameter to the DescribeCreateAccountStatus operation.
1118  
1119 =item *
1120  
1121 Check the AWS CloudTrail log for the C<CreateAccountResult> event. For
1122 information on using AWS CloudTrail with Organizations, see Monitoring
1123 the Activity in Your Organization
1124 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_monitoring.html)
1125 in the I<AWS Organizations User Guide.>
1126  
1127 =back
1128  
1129 When you call the C<CreateGovCloudAccount> action, you create two
1130 accounts: a standalone account in the AWS GovCloud (US) Region and an
1131 associated account in the commercial Region for billing and support
1132 purposes. The account in the commercial Region is automatically a
1133 member of the organization whose credentials made the request. Both
1134 accounts are associated with the same email address.
1135  
1136 A role is created in the new account in the commercial Region that
1137 allows the management account in the organization in the commercial
1138 Region to assume it. An AWS GovCloud (US) account is then created and
1139 associated with the commercial account that you just created. A role is
1140 also created in the new AWS GovCloud (US) account that can be assumed
1141 by the AWS GovCloud (US) account that is associated with the management
1142 account of the commercial organization. For more information and to
1143 view a diagram that explains how account access works, see AWS
1144 Organizations
1145 (http://docs.aws.amazon.com/govcloud-us/latest/UserGuide/govcloud-organizations.html)
1146 in the I<AWS GovCloud User Guide.>
1147  
1148 For more information about creating accounts, see Creating an AWS
1149 Account in Your Organization
1150 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_create.html)
1151 in the I<AWS Organizations User Guide.>
1152  
1153 =over
1154  
1155 =item *
1156  
1157 When you create an account in an organization using the AWS
1158 Organizations console, API, or CLI commands, the information required
1159 for the account to operate as a standalone account is I<not>
1160 automatically collected. This includes a payment method and signing the
1161 end user license agreement (EULA). If you must remove an account from
1162 your organization later, you can do so only after you provide the
1163 missing information. Follow the steps at To leave an organization as a
1164 member account
1165 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_remove.html#leave-without-all-info)
1166 in the I<AWS Organizations User Guide.>
1167  
1168 =item *
1169  
1170 If you get an exception that indicates that you exceeded your account
1171 limits for the organization, contact AWS Support
1172 (https://console.aws.amazon.com/support/home#/).
1173  
1174 =item *
1175  
1176 If you get an exception that indicates that the operation failed
1177 because your organization is still initializing, wait one hour and then
1178 try again. If the error persists, contact AWS Support
1179 (https://console.aws.amazon.com/support/home#/).
1180  
1181 =item *
1182  
1183 Using C<CreateGovCloudAccount> to create multiple temporary accounts
1184 isn't recommended. You can only close an account from the AWS Billing
1185 and Cost Management console, and you must be signed in as the root
1186 user. For information on the requirements and process for closing an
1187 account, see Closing an AWS Account
1188 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_close.html)
1189 in the I<AWS Organizations User Guide>.
1190  
1191 =back
1192  
1193 When you create a member account with this operation, you can choose
1194 whether to create the account with the B<IAM User and Role Access to
1195 Billing Information> switch enabled. If you enable it, IAM users and
1196 roles that have appropriate permissions can view billing information
1197 for the account. If you disable it, only the account root user can
1198 access billing information. For information about how to disable this
1199 switch for an account, see Granting Access to Your Billing Information
1200 and Tools
1201 (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/grantaccess.html).
1202  
1203  
1204 =head2 CreateOrganization
1205  
1206 =over
1207  
1208 =item [FeatureSet => Str]
1209  
1210  
1211 =back
1212  
1213 Each argument is described in detail in: L<Paws::Organizations::CreateOrganization>
1214  
1215 Returns: a L<Paws::Organizations::CreateOrganizationResponse> instance
1216  
1217 Creates an AWS organization. The account whose user is calling the
1218 C<CreateOrganization> operation automatically becomes the management
1219 account
1220 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_getting-started_concepts.html#account)
1221 of the new organization.
1222  
1223 This operation must be called using credentials from the account that
1224 is to become the new organization's management account. The principal
1225 must also have the relevant IAM permissions.
1226  
1227 By default (or if you set the C<FeatureSet> parameter to C<ALL>), the
1228 new organization is created with all features enabled and service
1229 control policies automatically enabled in the root. If you instead
1230 choose to create the organization supporting only the consolidated
1231 billing features by setting the C<FeatureSet> parameter to
1232 C<CONSOLIDATED_BILLING">, no policy types are enabled by default, and
1233 you can't use organization policies
1234  
1235  
1236 =head2 CreateOrganizationalUnit
1237  
1238 =over
1239  
1240 =item Name => Str
1241  
1242 =item ParentId => Str
1243  
1244 =item [Tags => ArrayRef[L<Paws::Organizations::Tag>]]
1245  
1246  
1247 =back
1248  
1249 Each argument is described in detail in: L<Paws::Organizations::CreateOrganizationalUnit>
1250  
1251 Returns: a L<Paws::Organizations::CreateOrganizationalUnitResponse> instance
1252  
1253 Creates an organizational unit (OU) within a root or parent OU. An OU
1254 is a container for accounts that enables you to organize your accounts
1255 to apply policies according to your business requirements. The number
1256 of levels deep that you can nest OUs is dependent upon the policy types
1257 enabled for that root. For service control policies, the limit is five.
1258  
1259 For more information about OUs, see Managing Organizational Units
1260 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_ous.html)
1261 in the I<AWS Organizations User Guide.>
1262  
1263 If the request includes tags, then the requester must have the
1264 C<organizations:TagResource> permission.
1265  
1266 This operation can be called only from the organization's management
1267 account.
1268  
1269  
1270 =head2 CreatePolicy
1271  
1272 =over
1273  
1274 =item Content => Str
1275  
1276 =item Description => Str
1277  
1278 =item Name => Str
1279  
1280 =item Type => Str
1281  
1282 =item [Tags => ArrayRef[L<Paws::Organizations::Tag>]]
1283  
1284  
1285 =back
1286  
1287 Each argument is described in detail in: L<Paws::Organizations::CreatePolicy>
1288  
1289 Returns: a L<Paws::Organizations::CreatePolicyResponse> instance
1290  
1291 Creates a policy of a specified type that you can attach to a root, an
1292 organizational unit (OU), or an individual AWS account.
1293  
1294 For more information about policies and their use, see Managing
1295 Organization Policies
1296 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies.html).
1297  
1298 If the request includes tags, then the requester must have the
1299 C<organizations:TagResource> permission.
1300  
1301 This operation can be called only from the organization's management
1302 account.
1303  
1304  
1305 =head2 DeclineHandshake
1306  
1307 =over
1308  
1309 =item HandshakeId => Str
1310  
1311  
1312 =back
1313  
1314 Each argument is described in detail in: L<Paws::Organizations::DeclineHandshake>
1315  
1316 Returns: a L<Paws::Organizations::DeclineHandshakeResponse> instance
1317  
1318 Declines a handshake request. This sets the handshake state to
1319 C<DECLINED> and effectively deactivates the request.
1320  
1321 This operation can be called only from the account that received the
1322 handshake. The originator of the handshake can use CancelHandshake
1323 instead. The originator can't reactivate a declined request, but can
1324 reinitiate the process with a new handshake request.
1325  
1326 After you decline a handshake, it continues to appear in the results of
1327 relevant APIs for only 30 days. After that, it's deleted.
1328  
1329  
1330 =head2 DeleteOrganization
1331  
1332 =over
1333  
1334 =item =>
1335  
1336  
1337 =back
1338  
1339 Each argument is described in detail in: L<Paws::Organizations::DeleteOrganization>
1340  
1341 Returns: nothing
1342  
1343 Deletes the organization. You can delete an organization only by using
1344 credentials from the management account. The organization must be empty
1345 of member accounts.
1346  
1347  
1348 =head2 DeleteOrganizationalUnit
1349  
1350 =over
1351  
1352 =item OrganizationalUnitId => Str
1353  
1354  
1355 =back
1356  
1357 Each argument is described in detail in: L<Paws::Organizations::DeleteOrganizationalUnit>
1358  
1359 Returns: nothing
1360  
1361 Deletes an organizational unit (OU) from a root or another OU. You must
1362 first remove all accounts and child OUs from the OU that you want to
1363 delete.
1364  
1365 This operation can be called only from the organization's management
1366 account.
1367  
1368  
1369 =head2 DeletePolicy
1370  
1371 =over
1372  
1373 =item PolicyId => Str
1374  
1375  
1376 =back
1377  
1378 Each argument is described in detail in: L<Paws::Organizations::DeletePolicy>
1379  
1380 Returns: nothing
1381  
1382 Deletes the specified policy from your organization. Before you perform
1383 this operation, you must first detach the policy from all
1384 organizational units (OUs), roots, and accounts.
1385  
1386 This operation can be called only from the organization's management
1387 account.
1388  
1389  
1390 =head2 DeregisterDelegatedAdministrator
1391  
1392 =over
1393  
1394 =item AccountId => Str
1395  
1396 =item ServicePrincipal => Str
1397  
1398  
1399 =back
1400  
1401 Each argument is described in detail in: L<Paws::Organizations::DeregisterDelegatedAdministrator>
1402  
1403 Returns: nothing
1404  
1405 Removes the specified member AWS account as a delegated administrator
1406 for the specified AWS service.
1407  
1408 Deregistering a delegated administrator can have unintended impacts on
1409 the functionality of the enabled AWS service. See the documentation for
1410 the enabled service before you deregister a delegated administrator so
1411 that you understand any potential impacts.
1412  
1413 You can run this action only for AWS services that support this
1414 feature. For a current list of services that support it, see the column
1415 I<Supports Delegated Administrator> in the table at AWS Services that
1416 you can use with AWS Organizations
1417 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services_list.html)
1418 in the I<AWS Organizations User Guide.>
1419  
1420 This operation can be called only from the organization's management
1421 account.
1422  
1423  
1424 =head2 DescribeAccount
1425  
1426 =over
1427  
1428 =item AccountId => Str
1429  
1430  
1431 =back
1432  
1433 Each argument is described in detail in: L<Paws::Organizations::DescribeAccount>
1434  
1435 Returns: a L<Paws::Organizations::DescribeAccountResponse> instance
1436  
1437 Retrieves AWS Organizations-related information about the specified
1438 account.
1439  
1440 This operation can be called only from the organization's management
1441 account or by a member account that is a delegated administrator for an
1442 AWS service.
1443  
1444  
1445 =head2 DescribeCreateAccountStatus
1446  
1447 =over
1448  
1449 =item CreateAccountRequestId => Str
1450  
1451  
1452 =back
1453  
1454 Each argument is described in detail in: L<Paws::Organizations::DescribeCreateAccountStatus>
1455  
1456 Returns: a L<Paws::Organizations::DescribeCreateAccountStatusResponse> instance
1457  
1458 Retrieves the current status of an asynchronous request to create an
1459 account.
1460  
1461 This operation can be called only from the organization's management
1462 account or by a member account that is a delegated administrator for an
1463 AWS service.
1464  
1465  
1466 =head2 DescribeEffectivePolicy
1467  
1468 =over
1469  
1470 =item PolicyType => Str
1471  
1472 =item [TargetId => Str]
1473  
1474  
1475 =back
1476  
1477 Each argument is described in detail in: L<Paws::Organizations::DescribeEffectivePolicy>
1478  
1479 Returns: a L<Paws::Organizations::DescribeEffectivePolicyResponse> instance
1480  
1481 Returns the contents of the effective policy for specified policy type
1482 and account. The effective policy is the aggregation of any policies of
1483 the specified type that the account inherits, plus any policy of that
1484 type that is directly attached to the account.
1485  
1486 This operation applies only to policy types I<other> than service
1487 control policies (SCPs).
1488  
1489 For more information about policy inheritance, see How Policy
1490 Inheritance Works
1491 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies-inheritance.html)
1492 in the I<AWS Organizations User Guide>.
1493  
1494 This operation can be called only from the organization's management
1495 account or by a member account that is a delegated administrator for an
1496 AWS service.
1497  
1498  
1499 =head2 DescribeHandshake
1500  
1501 =over
1502  
1503 =item HandshakeId => Str
1504  
1505  
1506 =back
1507  
1508 Each argument is described in detail in: L<Paws::Organizations::DescribeHandshake>
1509  
1510 Returns: a L<Paws::Organizations::DescribeHandshakeResponse> instance
1511  
1512 Retrieves information about a previously requested handshake. The
1513 handshake ID comes from the response to the original
1514 InviteAccountToOrganization operation that generated the handshake.
1515  
1516 You can access handshakes that are C<ACCEPTED>, C<DECLINED>, or
1517 C<CANCELED> for only 30 days after they change to that state. They're
1518 then deleted and no longer accessible.
1519  
1520 This operation can be called from any account in the organization.
1521  
1522  
1523 =head2 DescribeOrganization
1524  
1525 =over
1526  
1527 =item =>
1528  
1529  
1530 =back
1531  
1532 Each argument is described in detail in: L<Paws::Organizations::DescribeOrganization>
1533  
1534 Returns: a L<Paws::Organizations::DescribeOrganizationResponse> instance
1535  
1536 Retrieves information about the organization that the user's account
1537 belongs to.
1538  
1539 This operation can be called from any account in the organization.
1540  
1541 Even if a policy type is shown as available in the organization, you
1542 can disable it separately at the root level with DisablePolicyType. Use
1543 ListRoots to see the status of policy types for a specified root.
1544  
1545  
1546 =head2 DescribeOrganizationalUnit
1547  
1548 =over
1549  
1550 =item OrganizationalUnitId => Str
1551  
1552  
1553 =back
1554  
1555 Each argument is described in detail in: L<Paws::Organizations::DescribeOrganizationalUnit>
1556  
1557 Returns: a L<Paws::Organizations::DescribeOrganizationalUnitResponse> instance
1558  
1559 Retrieves information about an organizational unit (OU).
1560  
1561 This operation can be called only from the organization's management
1562 account or by a member account that is a delegated administrator for an
1563 AWS service.
1564  
1565  
1566 =head2 DescribePolicy
1567  
1568 =over
1569  
1570 =item PolicyId => Str
1571  
1572  
1573 =back
1574  
1575 Each argument is described in detail in: L<Paws::Organizations::DescribePolicy>
1576  
1577 Returns: a L<Paws::Organizations::DescribePolicyResponse> instance
1578  
1579 Retrieves information about a policy.
1580  
1581 This operation can be called only from the organization's management
1582 account or by a member account that is a delegated administrator for an
1583 AWS service.
1584  
1585  
1586 =head2 DetachPolicy
1587  
1588 =over
1589  
1590 =item PolicyId => Str
1591  
1592 =item TargetId => Str
1593  
1594  
1595 =back
1596  
1597 Each argument is described in detail in: L<Paws::Organizations::DetachPolicy>
1598  
1599 Returns: nothing
1600  
1601 Detaches a policy from a target root, organizational unit (OU), or
1602 account.
1603  
1604 If the policy being detached is a service control policy (SCP), the
1605 changes to permissions for AWS Identity and Access Management (IAM)
1606 users and roles in affected accounts are immediate.
1607  
1608 Every root, OU, and account must have at least one SCP attached. If you
1609 want to replace the default C<FullAWSAccess> policy with an SCP that
1610 limits the permissions that can be delegated, you must attach the
1611 replacement SCP before you can remove the default SCP. This is the
1612 authorization strategy of an "allow list
1613 (https://docs.aws.amazon.com/organizations/latest/userguide/SCP_strategies.html#orgs_policies_allowlist)".
1614 If you instead attach a second SCP and leave the C<FullAWSAccess> SCP
1615 still attached, and specify C<"Effect": "Deny"> in the second SCP to
1616 override the C<"Effect": "Allow"> in the C<FullAWSAccess> policy (or
1617 any other attached SCP), you're using the authorization strategy of a
1618 "deny list
1619 (https://docs.aws.amazon.com/organizations/latest/userguide/SCP_strategies.html#orgs_policies_denylist)".
1620  
1621 This operation can be called only from the organization's management
1622 account.
1623  
1624  
1625 =head2 DisableAWSServiceAccess
1626  
1627 =over
1628  
1629 =item ServicePrincipal => Str
1630  
1631  
1632 =back
1633  
1634 Each argument is described in detail in: L<Paws::Organizations::DisableAWSServiceAccess>
1635  
1636 Returns: nothing
1637  
1638 Disables the integration of an AWS service (the service that is
1639 specified by C<ServicePrincipal>) with AWS Organizations. When you
1640 disable integration, the specified service no longer can create a
1641 service-linked role
1642 (http://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html)
1643 in I<new> accounts in your organization. This means the service can't
1644 perform operations on your behalf on any new accounts in your
1645 organization. The service can still perform operations in older
1646 accounts until the service completes its clean-up from AWS
1647 Organizations.
1648  
1649 We B< I<strongly recommend> > that you don't use this command to
1650 disable integration between AWS Organizations and the specified AWS
1651 service. Instead, use the console or commands that are provided by the
1652 specified service. This lets the trusted service perform any required
1653 initialization when enabling trusted access, such as creating any
1654 required resources and any required clean up of resources when
1655 disabling trusted access.
1656  
1657 For information about how to disable trusted service access to your
1658 organization using the trusted service, see the B<Learn more> link
1659 under the B<Supports Trusted Access> column at AWS services that you
1660 can use with AWS Organizations
1661 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services_list.html).
1662 on this page.
1663  
1664 If you disable access by using this command, it causes the following
1665 actions to occur:
1666  
1667 =over
1668  
1669 =item *
1670  
1671 The service can no longer create a service-linked role in the accounts
1672 in your organization. This means that the service can't perform
1673 operations on your behalf on any new accounts in your organization. The
1674 service can still perform operations in older accounts until the
1675 service completes its clean-up from AWS Organizations.
1676  
1677 =item *
1678  
1679 The service can no longer perform tasks in the member accounts in the
1680 organization, unless those operations are explicitly permitted by the
1681 IAM policies that are attached to your roles. This includes any data
1682 aggregation from the member accounts to the management account, or to a
1683 delegated administrator account, where relevant.
1684  
1685 =item *
1686  
1687 Some services detect this and clean up any remaining data or resources
1688 related to the integration, while other services stop accessing the
1689 organization but leave any historical data and configuration in place
1690 to support a possible re-enabling of the integration.
1691  
1692 =back
1693  
1694 Using the other service's console or commands to disable the
1695 integration ensures that the other service is aware that it can clean
1696 up any resources that are required only for the integration. How the
1697 service cleans up its resources in the organization's accounts depends
1698 on that service. For more information, see the documentation for the
1699 other AWS service.
1700  
1701 After you perform the C<DisableAWSServiceAccess> operation, the
1702 specified service can no longer perform operations in your
1703 organization's accounts
1704  
1705 For more information about integrating other services with AWS
1706 Organizations, including the list of services that work with
1707 Organizations, see Integrating AWS Organizations with Other AWS
1708 Services
1709 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html)
1710 in the I<AWS Organizations User Guide.>
1711  
1712 This operation can be called only from the organization's management
1713 account.
1714  
1715  
1716 =head2 DisablePolicyType
1717  
1718 =over
1719  
1720 =item PolicyType => Str
1721  
1722 =item RootId => Str
1723  
1724  
1725 =back
1726  
1727 Each argument is described in detail in: L<Paws::Organizations::DisablePolicyType>
1728  
1729 Returns: a L<Paws::Organizations::DisablePolicyTypeResponse> instance
1730  
1731 Disables an organizational policy type in a root. A policy of a certain
1732 type can be attached to entities in a root only if that type is enabled
1733 in the root. After you perform this operation, you no longer can attach
1734 policies of the specified type to that root or to any organizational
1735 unit (OU) or account in that root. You can undo this by using the
1736 EnablePolicyType operation.
1737  
1738 This is an asynchronous request that AWS performs in the background. If
1739 you disable a policy type for a root, it still appears enabled for the
1740 organization if all features
1741 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html)
1742 are enabled for the organization. AWS recommends that you first use
1743 ListRoots to see the status of policy types for a specified root, and
1744 then use this operation.
1745  
1746 This operation can be called only from the organization's management
1747 account.
1748  
1749 To view the status of available policy types in the organization, use
1750 DescribeOrganization.
1751  
1752  
1753 =head2 EnableAllFeatures
1754  
1755  
1756  
1757  
1758  
1759  
1760 Each argument is described in detail in: L<Paws::Organizations::EnableAllFeatures>
1761  
1762 Returns: a L<Paws::Organizations::EnableAllFeaturesResponse> instance
1763  
1764 Enables all features in an organization. This enables the use of
1765 organization policies that can restrict the services and actions that
1766 can be called in each account. Until you enable all features, you have
1767 access only to consolidated billing, and you can't use any of the
1768 advanced account administration features that AWS Organizations
1769 supports. For more information, see Enabling All Features in Your
1770 Organization
1771 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html)
1772 in the I<AWS Organizations User Guide.>
1773  
1774 This operation is required only for organizations that were created
1775 explicitly with only the consolidated billing features enabled. Calling
1776 this operation sends a handshake to every invited account in the
1777 organization. The feature set change can be finalized and the
1778 additional features enabled only after all administrators in the
1779 invited accounts approve the change by accepting the handshake.
1780  
1781 After you enable all features, you can separately enable or disable
1782 individual policy types in a root using EnablePolicyType and
1783 DisablePolicyType. To see the status of policy types in a root, use
1784 ListRoots.
1785  
1786 After all invited member accounts accept the handshake, you finalize
1787 the feature set change by accepting the handshake that contains
1788 C<"Action": "ENABLE_ALL_FEATURES">. This completes the change.
1789  
1790 After you enable all features in your organization, the management
1791 account in the organization can apply policies on all member accounts.
1792 These policies can restrict what users and even administrators in those
1793 accounts can do. The management account can apply policies that prevent
1794 accounts from leaving the organization. Ensure that your account
1795 administrators are aware of this.
1796  
1797 This operation can be called only from the organization's management
1798 account.
1799  
1800  
1801 =head2 EnableAWSServiceAccess
1802  
1803 =over
1804  
1805 =item ServicePrincipal => Str
1806  
1807  
1808 =back
1809  
1810 Each argument is described in detail in: L<Paws::Organizations::EnableAWSServiceAccess>
1811  
1812 Returns: nothing
1813  
1814 Enables the integration of an AWS service (the service that is
1815 specified by C<ServicePrincipal>) with AWS Organizations. When you
1816 enable integration, you allow the specified service to create a
1817 service-linked role
1818 (http://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html)
1819 in all the accounts in your organization. This allows the service to
1820 perform operations on your behalf in your organization and its
1821 accounts.
1822  
1823 We recommend that you enable integration between AWS Organizations and
1824 the specified AWS service by using the console or commands that are
1825 provided by the specified service. Doing so ensures that the service is
1826 aware that it can create the resources that are required for the
1827 integration. How the service creates those resources in the
1828 organization's accounts depends on that service. For more information,
1829 see the documentation for the other AWS service.
1830  
1831 For more information about enabling services to integrate with AWS
1832 Organizations, see Integrating AWS Organizations with Other AWS
1833 Services
1834 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html)
1835 in the I<AWS Organizations User Guide.>
1836  
1837 This operation can be called only from the organization's management
1838 account and only if the organization has enabled all features
1839 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html).
1840  
1841  
1842 =head2 EnablePolicyType
1843  
1844 =over
1845  
1846 =item PolicyType => Str
1847  
1848 =item RootId => Str
1849  
1850  
1851 =back
1852  
1853 Each argument is described in detail in: L<Paws::Organizations::EnablePolicyType>
1854  
1855 Returns: a L<Paws::Organizations::EnablePolicyTypeResponse> instance
1856  
1857 Enables a policy type in a root. After you enable a policy type in a
1858 root, you can attach policies of that type to the root, any
1859 organizational unit (OU), or account in that root. You can undo this by
1860 using the DisablePolicyType operation.
1861  
1862 This is an asynchronous request that AWS performs in the background.
1863 AWS recommends that you first use ListRoots to see the status of policy
1864 types for a specified root, and then use this operation.
1865  
1866 This operation can be called only from the organization's management
1867 account.
1868  
1869 You can enable a policy type in a root only if that policy type is
1870 available in the organization. To view the status of available policy
1871 types in the organization, use DescribeOrganization.
1872  
1873  
1874 =head2 InviteAccountToOrganization
1875  
1876 =over
1877  
1878 =item Target => L<Paws::Organizations::HandshakeParty>
1879  
1880 =item [Notes => Str]
1881  
1882 =item [Tags => ArrayRef[L<Paws::Organizations::Tag>]]
1883  
1884  
1885 =back
1886  
1887 Each argument is described in detail in: L<Paws::Organizations::InviteAccountToOrganization>
1888  
1889 Returns: a L<Paws::Organizations::InviteAccountToOrganizationResponse> instance
1890  
1891 Sends an invitation to another account to join your organization as a
1892 member account. AWS Organizations sends email on your behalf to the
1893 email address that is associated with the other account's owner. The
1894 invitation is implemented as a Handshake whose details are in the
1895 response.
1896  
1897 =over
1898  
1899 =item *
1900  
1901 You can invite AWS accounts only from the same seller as the management
1902 account. For example, if your organization's management account was
1903 created by Amazon Internet Services Pvt. Ltd (AISPL), an AWS seller in
1904 India, you can invite only other AISPL accounts to your organization.
1905 You can't combine accounts from AISPL and AWS or from any other AWS
1906 seller. For more information, see Consolidated Billing in India
1907 (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/useconsolidatedbilliing-India.html).
1908  
1909 =item *
1910  
1911 If you receive an exception that indicates that you exceeded your
1912 account limits for the organization or that the operation failed
1913 because your organization is still initializing, wait one hour and then
1914 try again. If the error persists after an hour, contact AWS Support
1915 (https://console.aws.amazon.com/support/home#/).
1916  
1917 =back
1918  
1919 If the request includes tags, then the requester must have the
1920 C<organizations:TagResource> permission.
1921  
1922 This operation can be called only from the organization's management
1923 account.
1924  
1925  
1926 =head2 LeaveOrganization
1927  
1928 =over
1929  
1930 =item =>
1931  
1932  
1933 =back
1934  
1935 Each argument is described in detail in: L<Paws::Organizations::LeaveOrganization>
1936  
1937 Returns: nothing
1938  
1939 Removes a member account from its parent organization. This version of
1940 the operation is performed by the account that wants to leave. To
1941 remove a member account as a user in the management account, use
1942 RemoveAccountFromOrganization instead.
1943  
1944 This operation can be called only from a member account in the
1945 organization.
1946  
1947 =over
1948  
1949 =item *
1950  
1951 The management account in an organization with all features enabled can
1952 set service control policies (SCPs) that can restrict what
1953 administrators of member accounts can do. This includes preventing them
1954 from successfully calling C<LeaveOrganization> and leaving the
1955 organization.
1956  
1957 =item *
1958  
1959 You can leave an organization as a member account only if the account
1960 is configured with the information required to operate as a standalone
1961 account. When you create an account in an organization using the AWS
1962 Organizations console, API, or CLI commands, the information required
1963 of standalone accounts is I<not> automatically collected. For each
1964 account that you want to make standalone, you must perform the
1965 following steps. If any of the steps are already completed for this
1966 account, that step doesn't appear.
1967  
1968 =over
1969  
1970 =item *
1971  
1972 Choose a support plan
1973  
1974 =item *
1975  
1976 Provide and verify the required contact information
1977  
1978 =item *
1979  
1980 Provide a current payment method
1981  
1982 =back
1983  
1984 AWS uses the payment method to charge for any billable (not free tier)
1985 AWS activity that occurs while the account isn't attached to an
1986 organization. Follow the steps at To leave an organization when all
1987 required account information has not yet been provided
1988 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_remove.html#leave-without-all-info)
1989 in the I<AWS Organizations User Guide.>
1990  
1991 =item *
1992  
1993 The account that you want to leave must not be a delegated
1994 administrator account for any AWS service enabled for your
1995 organization. If the account is a delegated administrator, you must
1996 first change the delegated administrator account to another account
1997 that is remaining in the organization.
1998  
1999 =item *
2000  
2001 You can leave an organization only after you enable IAM user access to
2002 billing in your account. For more information, see Activating Access to
2003 the Billing and Cost Management Console
2004 (http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/grantaccess.html#ControllingAccessWebsite-Activate)
2005 in the I<AWS Billing and Cost Management User Guide.>
2006  
2007 =item *
2008  
2009 After the account leaves the organization, all tags that were attached
2010 to the account object in the organization are deleted. AWS accounts
2011 outside of an organization do not support tags.
2012  
2013 =item *
2014  
2015 A newly created account has a waiting period before it can be removed
2016 from its organization. If you get an error that indicates that a wait
2017 period is required, then try again in a few days.
2018  
2019 =back
2020  
2021  
2022  
2023 =head2 ListAccounts
2024  
2025 =over
2026  
2027 =item [MaxResults => Int]
2028  
2029 =item [NextToken => Str]
2030  
2031  
2032 =back
2033  
2034 Each argument is described in detail in: L<Paws::Organizations::ListAccounts>
2035  
2036 Returns: a L<Paws::Organizations::ListAccountsResponse> instance
2037  
2038 Lists all the accounts in the organization. To request only the
2039 accounts in a specified root or organizational unit (OU), use the
2040 ListAccountsForParent operation instead.
2041  
2042 Always check the C<NextToken> response parameter for a C<null> value
2043 when calling a C<List*> operation. These operations can occasionally
2044 return an empty set of results even when there are more results
2045 available. The C<NextToken> response parameter value is C<null> I<only>
2046 when there are no more results to display.
2047  
2048 This operation can be called only from the organization's management
2049 account or by a member account that is a delegated administrator for an
2050 AWS service.
2051  
2052  
2053 =head2 ListAccountsForParent
2054  
2055 =over
2056  
2057 =item ParentId => Str
2058  
2059 =item [MaxResults => Int]
2060  
2061 =item [NextToken => Str]
2062  
2063  
2064 =back
2065  
2066 Each argument is described in detail in: L<Paws::Organizations::ListAccountsForParent>
2067  
2068 Returns: a L<Paws::Organizations::ListAccountsForParentResponse> instance
2069  
2070 Lists the accounts in an organization that are contained by the
2071 specified target root or organizational unit (OU). If you specify the
2072 root, you get a list of all the accounts that aren't in any OU. If you
2073 specify an OU, you get a list of all the accounts in only that OU and
2074 not in any child OUs. To get a list of all accounts in the
2075 organization, use the ListAccounts operation.
2076  
2077 Always check the C<NextToken> response parameter for a C<null> value
2078 when calling a C<List*> operation. These operations can occasionally
2079 return an empty set of results even when there are more results
2080 available. The C<NextToken> response parameter value is C<null> I<only>
2081 when there are no more results to display.
2082  
2083 This operation can be called only from the organization's management
2084 account or by a member account that is a delegated administrator for an
2085 AWS service.
2086  
2087  
2088 =head2 ListAWSServiceAccessForOrganization
2089  
2090 =over
2091  
2092 =item [MaxResults => Int]
2093  
2094 =item [NextToken => Str]
2095  
2096  
2097 =back
2098  
2099 Each argument is described in detail in: L<Paws::Organizations::ListAWSServiceAccessForOrganization>
2100  
2101 Returns: a L<Paws::Organizations::ListAWSServiceAccessForOrganizationResponse> instance
2102  
2103 Returns a list of the AWS services that you enabled to integrate with
2104 your organization. After a service on this list creates the resources
2105 that it requires for the integration, it can perform operations on your
2106 organization and its accounts.
2107  
2108 For more information about integrating other services with AWS
2109 Organizations, including the list of services that currently work with
2110 Organizations, see Integrating AWS Organizations with Other AWS
2111 Services
2112 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html)
2113 in the I<AWS Organizations User Guide.>
2114  
2115 This operation can be called only from the organization's management
2116 account or by a member account that is a delegated administrator for an
2117 AWS service.
2118  
2119  
2120 =head2 ListChildren
2121  
2122 =over
2123  
2124 =item ChildType => Str
2125  
2126 =item ParentId => Str
2127  
2128 =item [MaxResults => Int]
2129  
2130 =item [NextToken => Str]
2131  
2132  
2133 =back
2134  
2135 Each argument is described in detail in: L<Paws::Organizations::ListChildren>
2136  
2137 Returns: a L<Paws::Organizations::ListChildrenResponse> instance
2138  
2139 Lists all of the organizational units (OUs) or accounts that are
2140 contained in the specified parent OU or root. This operation, along
2141 with ListParents enables you to traverse the tree structure that makes
2142 up this root.
2143  
2144 Always check the C<NextToken> response parameter for a C<null> value
2145 when calling a C<List*> operation. These operations can occasionally
2146 return an empty set of results even when there are more results
2147 available. The C<NextToken> response parameter value is C<null> I<only>
2148 when there are no more results to display.
2149  
2150 This operation can be called only from the organization's management
2151 account or by a member account that is a delegated administrator for an
2152 AWS service.
2153  
2154  
2155 =head2 ListCreateAccountStatus
2156  
2157 =over
2158  
2159 =item [MaxResults => Int]
2160  
2161 =item [NextToken => Str]
2162  
2163 =item [States => ArrayRef[Str|Undef]]
2164  
2165  
2166 =back
2167  
2168 Each argument is described in detail in: L<Paws::Organizations::ListCreateAccountStatus>
2169  
2170 Returns: a L<Paws::Organizations::ListCreateAccountStatusResponse> instance
2171  
2172 Lists the account creation requests that match the specified status
2173 that is currently being tracked for the organization.
2174  
2175 Always check the C<NextToken> response parameter for a C<null> value
2176 when calling a C<List*> operation. These operations can occasionally
2177 return an empty set of results even when there are more results
2178 available. The C<NextToken> response parameter value is C<null> I<only>
2179 when there are no more results to display.
2180  
2181 This operation can be called only from the organization's management
2182 account or by a member account that is a delegated administrator for an
2183 AWS service.
2184  
2185  
2186 =head2 ListDelegatedAdministrators
2187  
2188 =over
2189  
2190 =item [MaxResults => Int]
2191  
2192 =item [NextToken => Str]
2193  
2194 =item [ServicePrincipal => Str]
2195  
2196  
2197 =back
2198  
2199 Each argument is described in detail in: L<Paws::Organizations::ListDelegatedAdministrators>
2200  
2201 Returns: a L<Paws::Organizations::ListDelegatedAdministratorsResponse> instance
2202  
2203 Lists the AWS accounts that are designated as delegated administrators
2204 in this organization.
2205  
2206 This operation can be called only from the organization's management
2207 account or by a member account that is a delegated administrator for an
2208 AWS service.
2209  
2210  
2211 =head2 ListDelegatedServicesForAccount
2212  
2213 =over
2214  
2215 =item AccountId => Str
2216  
2217 =item [MaxResults => Int]
2218  
2219 =item [NextToken => Str]
2220  
2221  
2222 =back
2223  
2224 Each argument is described in detail in: L<Paws::Organizations::ListDelegatedServicesForAccount>
2225  
2226 Returns: a L<Paws::Organizations::ListDelegatedServicesForAccountResponse> instance
2227  
2228 List the AWS services for which the specified account is a delegated
2229 administrator.
2230  
2231 This operation can be called only from the organization's management
2232 account or by a member account that is a delegated administrator for an
2233 AWS service.
2234  
2235  
2236 =head2 ListHandshakesForAccount
2237  
2238 =over
2239  
2240 =item [Filter => L<Paws::Organizations::HandshakeFilter>]
2241  
2242 =item [MaxResults => Int]
2243  
2244 =item [NextToken => Str]
2245  
2246  
2247 =back
2248  
2249 Each argument is described in detail in: L<Paws::Organizations::ListHandshakesForAccount>
2250  
2251 Returns: a L<Paws::Organizations::ListHandshakesForAccountResponse> instance
2252  
2253 Lists the current handshakes that are associated with the account of
2254 the requesting user.
2255  
2256 Handshakes that are C<ACCEPTED>, C<DECLINED>, or C<CANCELED> appear in
2257 the results of this API for only 30 days after changing to that state.
2258 After that, they're deleted and no longer accessible.
2259  
2260 Always check the C<NextToken> response parameter for a C<null> value
2261 when calling a C<List*> operation. These operations can occasionally
2262 return an empty set of results even when there are more results
2263 available. The C<NextToken> response parameter value is C<null> I<only>
2264 when there are no more results to display.
2265  
2266 This operation can be called from any account in the organization.
2267  
2268  
2269 =head2 ListHandshakesForOrganization
2270  
2271 =over
2272  
2273 =item [Filter => L<Paws::Organizations::HandshakeFilter>]
2274  
2275 =item [MaxResults => Int]
2276  
2277 =item [NextToken => Str]
2278  
2279  
2280 =back
2281  
2282 Each argument is described in detail in: L<Paws::Organizations::ListHandshakesForOrganization>
2283  
2284 Returns: a L<Paws::Organizations::ListHandshakesForOrganizationResponse> instance
2285  
2286 Lists the handshakes that are associated with the organization that the
2287 requesting user is part of. The C<ListHandshakesForOrganization>
2288 operation returns a list of handshake structures. Each structure
2289 contains details and status about a handshake.
2290  
2291 Handshakes that are C<ACCEPTED>, C<DECLINED>, or C<CANCELED> appear in
2292 the results of this API for only 30 days after changing to that state.
2293 After that, they're deleted and no longer accessible.
2294  
2295 Always check the C<NextToken> response parameter for a C<null> value
2296 when calling a C<List*> operation. These operations can occasionally
2297 return an empty set of results even when there are more results
2298 available. The C<NextToken> response parameter value is C<null> I<only>
2299 when there are no more results to display.
2300  
2301 This operation can be called only from the organization's management
2302 account or by a member account that is a delegated administrator for an
2303 AWS service.
2304  
2305  
2306 =head2 ListOrganizationalUnitsForParent
2307  
2308 =over
2309  
2310 =item ParentId => Str
2311  
2312 =item [MaxResults => Int]
2313  
2314 =item [NextToken => Str]
2315  
2316  
2317 =back
2318  
2319 Each argument is described in detail in: L<Paws::Organizations::ListOrganizationalUnitsForParent>
2320  
2321 Returns: a L<Paws::Organizations::ListOrganizationalUnitsForParentResponse> instance
2322  
2323 Lists the organizational units (OUs) in a parent organizational unit or
2324 root.
2325  
2326 Always check the C<NextToken> response parameter for a C<null> value
2327 when calling a C<List*> operation. These operations can occasionally
2328 return an empty set of results even when there are more results
2329 available. The C<NextToken> response parameter value is C<null> I<only>
2330 when there are no more results to display.
2331  
2332 This operation can be called only from the organization's management
2333 account or by a member account that is a delegated administrator for an
2334 AWS service.
2335  
2336  
2337 =head2 ListParents
2338  
2339 =over
2340  
2341 =item ChildId => Str
2342  
2343 =item [MaxResults => Int]
2344  
2345 =item [NextToken => Str]
2346  
2347  
2348 =back
2349  
2350 Each argument is described in detail in: L<Paws::Organizations::ListParents>
2351  
2352 Returns: a L<Paws::Organizations::ListParentsResponse> instance
2353  
2354 Lists the root or organizational units (OUs) that serve as the
2355 immediate parent of the specified child OU or account. This operation,
2356 along with ListChildren enables you to traverse the tree structure that
2357 makes up this root.
2358  
2359 Always check the C<NextToken> response parameter for a C<null> value
2360 when calling a C<List*> operation. These operations can occasionally
2361 return an empty set of results even when there are more results
2362 available. The C<NextToken> response parameter value is C<null> I<only>
2363 when there are no more results to display.
2364  
2365 This operation can be called only from the organization's management
2366 account or by a member account that is a delegated administrator for an
2367 AWS service.
2368  
2369 In the current release, a child can have only a single parent.
2370  
2371  
2372 =head2 ListPolicies
2373  
2374 =over
2375  
2376 =item Filter => Str
2377  
2378 =item [MaxResults => Int]
2379  
2380 =item [NextToken => Str]
2381  
2382  
2383 =back
2384  
2385 Each argument is described in detail in: L<Paws::Organizations::ListPolicies>
2386  
2387 Returns: a L<Paws::Organizations::ListPoliciesResponse> instance
2388  
2389 Retrieves the list of all policies in an organization of a specified
2390 type.
2391  
2392 Always check the C<NextToken> response parameter for a C<null> value
2393 when calling a C<List*> operation. These operations can occasionally
2394 return an empty set of results even when there are more results
2395 available. The C<NextToken> response parameter value is C<null> I<only>
2396 when there are no more results to display.
2397  
2398 This operation can be called only from the organization's management
2399 account or by a member account that is a delegated administrator for an
2400 AWS service.
2401  
2402  
2403 =head2 ListPoliciesForTarget
2404  
2405 =over
2406  
2407 =item Filter => Str
2408  
2409 =item TargetId => Str
2410  
2411 =item [MaxResults => Int]
2412  
2413 =item [NextToken => Str]
2414  
2415  
2416 =back
2417  
2418 Each argument is described in detail in: L<Paws::Organizations::ListPoliciesForTarget>
2419  
2420 Returns: a L<Paws::Organizations::ListPoliciesForTargetResponse> instance
2421  
2422 Lists the policies that are directly attached to the specified target
2423 root, organizational unit (OU), or account. You must specify the policy
2424 type that you want included in the returned list.
2425  
2426 Always check the C<NextToken> response parameter for a C<null> value
2427 when calling a C<List*> operation. These operations can occasionally
2428 return an empty set of results even when there are more results
2429 available. The C<NextToken> response parameter value is C<null> I<only>
2430 when there are no more results to display.
2431  
2432 This operation can be called only from the organization's management
2433 account or by a member account that is a delegated administrator for an
2434 AWS service.
2435  
2436  
2437 =head2 ListRoots
2438  
2439 =over
2440  
2441 =item [MaxResults => Int]
2442  
2443 =item [NextToken => Str]
2444  
2445  
2446 =back
2447  
2448 Each argument is described in detail in: L<Paws::Organizations::ListRoots>
2449  
2450 Returns: a L<Paws::Organizations::ListRootsResponse> instance
2451  
2452 Lists the roots that are defined in the current organization.
2453  
2454 Always check the C<NextToken> response parameter for a C<null> value
2455 when calling a C<List*> operation. These operations can occasionally
2456 return an empty set of results even when there are more results
2457 available. The C<NextToken> response parameter value is C<null> I<only>
2458 when there are no more results to display.
2459  
2460 This operation can be called only from the organization's management
2461 account or by a member account that is a delegated administrator for an
2462 AWS service.
2463  
2464 Policy types can be enabled and disabled in roots. This is distinct
2465 from whether they're available in the organization. When you enable all
2466 features, you make policy types available for use in that organization.
2467 Individual policy types can then be enabled and disabled in a root. To
2468 see the availability of a policy type in an organization, use
2469 DescribeOrganization.
2470  
2471  
2472 =head2 ListTagsForResource
2473  
2474 =over
2475  
2476 =item ResourceId => Str
2477  
2478 =item [NextToken => Str]
2479  
2480  
2481 =back
2482  
2483 Each argument is described in detail in: L<Paws::Organizations::ListTagsForResource>
2484  
2485 Returns: a L<Paws::Organizations::ListTagsForResourceResponse> instance
2486  
2487 Lists tags that are attached to the specified resource.
2488  
2489 You can attach tags to the following resources in AWS Organizations.
2490  
2491 =over
2492  
2493 =item *
2494  
2495 AWS account
2496  
2497 =item *
2498  
2499 Organization root
2500  
2501 =item *
2502  
2503 Organizational unit (OU)
2504  
2505 =item *
2506  
2507 Policy (any type)
2508  
2509 =back
2510  
2511 This operation can be called only from the organization's management
2512 account or by a member account that is a delegated administrator for an
2513 AWS service.
2514  
2515  
2516 =head2 ListTargetsForPolicy
2517  
2518 =over
2519  
2520 =item PolicyId => Str
2521  
2522 =item [MaxResults => Int]
2523  
2524 =item [NextToken => Str]
2525  
2526  
2527 =back
2528  
2529 Each argument is described in detail in: L<Paws::Organizations::ListTargetsForPolicy>
2530  
2531 Returns: a L<Paws::Organizations::ListTargetsForPolicyResponse> instance
2532  
2533 Lists all the roots, organizational units (OUs), and accounts that the
2534 specified policy is attached to.
2535  
2536 Always check the C<NextToken> response parameter for a C<null> value
2537 when calling a C<List*> operation. These operations can occasionally
2538 return an empty set of results even when there are more results
2539 available. The C<NextToken> response parameter value is C<null> I<only>
2540 when there are no more results to display.
2541  
2542 This operation can be called only from the organization's management
2543 account or by a member account that is a delegated administrator for an
2544 AWS service.
2545  
2546  
2547 =head2 MoveAccount
2548  
2549 =over
2550  
2551 =item AccountId => Str
2552  
2553 =item DestinationParentId => Str
2554  
2555 =item SourceParentId => Str
2556  
2557  
2558 =back
2559  
2560 Each argument is described in detail in: L<Paws::Organizations::MoveAccount>
2561  
2562 Returns: nothing
2563  
2564 Moves an account from its current source parent root or organizational
2565 unit (OU) to the specified destination parent root or OU.
2566  
2567 This operation can be called only from the organization's management
2568 account.
2569  
2570  
2571 =head2 RegisterDelegatedAdministrator
2572  
2573 =over
2574  
2575 =item AccountId => Str
2576  
2577 =item ServicePrincipal => Str
2578  
2579  
2580 =back
2581  
2582 Each argument is described in detail in: L<Paws::Organizations::RegisterDelegatedAdministrator>
2583  
2584 Returns: nothing
2585  
2586 Enables the specified member account to administer the Organizations
2587 features of the specified AWS service. It grants read-only access to
2588 AWS Organizations service data. The account still requires IAM
2589 permissions to access and administer the AWS service.
2590  
2591 You can run this action only for AWS services that support this
2592 feature. For a current list of services that support it, see the column
2593 I<Supports Delegated Administrator> in the table at AWS Services that
2594 you can use with AWS Organizations
2595 (https://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services_list.html)
2596 in the I<AWS Organizations User Guide.>
2597  
2598 This operation can be called only from the organization's management
2599 account.
2600  
2601  
2602 =head2 RemoveAccountFromOrganization
2603  
2604 =over
2605  
2606 =item AccountId => Str
2607  
2608  
2609 =back
2610  
2611 Each argument is described in detail in: L<Paws::Organizations::RemoveAccountFromOrganization>
2612  
2613 Returns: nothing
2614  
2615 Removes the specified account from the organization.
2616  
2617 The removed account becomes a standalone account that isn't a member of
2618 any organization. It's no longer subject to any policies and is
2619 responsible for its own bill payments. The organization's management
2620 account is no longer charged for any expenses accrued by the member
2621 account after it's removed from the organization.
2622  
2623 This operation can be called only from the organization's management
2624 account. Member accounts can remove themselves with LeaveOrganization
2625 instead.
2626  
2627 =over
2628  
2629 =item *
2630  
2631 You can remove an account from your organization only if the account is
2632 configured with the information required to operate as a standalone
2633 account. When you create an account in an organization using the AWS
2634 Organizations console, API, or CLI commands, the information required
2635 of standalone accounts is I<not> automatically collected. For an
2636 account that you want to make standalone, you must choose a support
2637 plan, provide and verify the required contact information, and provide
2638 a current payment method. AWS uses the payment method to charge for any
2639 billable (not free tier) AWS activity that occurs while the account
2640 isn't attached to an organization. To remove an account that doesn't
2641 yet have this information, you must sign in as the member account and
2642 follow the steps at To leave an organization when all required account
2643 information has not yet been provided
2644 (http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_remove.html#leave-without-all-info)
2645 in the I<AWS Organizations User Guide.>
2646  
2647 =item *
2648  
2649 The account that you want to leave must not be a delegated
2650 administrator account for any AWS service enabled for your
2651 organization. If the account is a delegated administrator, you must
2652 first change the delegated administrator account to another account
2653 that is remaining in the organization.
2654  
2655 =item *
2656  
2657 After the account leaves the organization, all tags that were attached
2658 to the account object in the organization are deleted. AWS accounts
2659 outside of an organization do not support tags.
2660  
2661 =back
2662  
2663  
2664  
2665 =head2 TagResource
2666  
2667 =over
2668  
2669 =item ResourceId => Str
2670  
2671 =item Tags => ArrayRef[L<Paws::Organizations::Tag>]
2672  
2673  
2674 =back
2675  
2676 Each argument is described in detail in: L<Paws::Organizations::TagResource>
2677  
2678 Returns: nothing
2679  
2680 Adds one or more tags to the specified resource.
2681  
2682 Currently, you can attach tags to the following resources in AWS
2683 Organizations.
2684  
2685 =over
2686  
2687 =item *
2688  
2689 AWS account
2690  
2691 =item *
2692  
2693 Organization root
2694  
2695 =item *
2696  
2697 Organizational unit (OU)
2698  
2699 =item *
2700  
2701 Policy (any type)
2702  
2703 =back
2704  
2705 This operation can be called only from the organization's management
2706 account.
2707  
2708  
2709 =head2 UntagResource
2710  
2711 =over
2712  
2713 =item ResourceId => Str
2714  
2715 =item TagKeys => ArrayRef[Str|Undef]
2716  
2717  
2718 =back
2719  
2720 Each argument is described in detail in: L<Paws::Organizations::UntagResource>
2721  
2722 Returns: nothing
2723  
2724 Removes any tags with the specified keys from the specified resource.
2725  
2726 You can attach tags to the following resources in AWS Organizations.
2727  
2728 =over
2729  
2730 =item *
2731  
2732 AWS account
2733  
2734 =item *
2735  
2736 Organization root
2737  
2738 =item *
2739  
2740 Organizational unit (OU)
2741  
2742 =item *
2743  
2744 Policy (any type)
2745  
2746 =back
2747  
2748 This operation can be called only from the organization's management
2749 account.
2750  
2751  
2752 =head2 UpdateOrganizationalUnit
2753  
2754 =over
2755  
2756 =item OrganizationalUnitId => Str
2757  
2758 =item [Name => Str]
2759  
2760  
2761 =back
2762  
2763 Each argument is described in detail in: L<Paws::Organizations::UpdateOrganizationalUnit>
2764  
2765 Returns: a L<Paws::Organizations::UpdateOrganizationalUnitResponse> instance
2766  
2767 Renames the specified organizational unit (OU). The ID and ARN don't
2768 change. The child OUs and accounts remain in place, and any attached
2769 policies of the OU remain attached.
2770  
2771 This operation can be called only from the organization's management
2772 account.
2773  
2774  
2775 =head2 UpdatePolicy
2776  
2777 =over
2778  
2779 =item PolicyId => Str
2780  
2781 =item [Content => Str]
2782  
2783 =item [Description => Str]
2784  
2785 =item [Name => Str]
2786  
2787  
2788 =back
2789  
2790 Each argument is described in detail in: L<Paws::Organizations::UpdatePolicy>
2791  
2792 Returns: a L<Paws::Organizations::UpdatePolicyResponse> instance
2793  
2794 Updates an existing policy with a new name, description, or content. If
2795 you don't supply any parameter, that value remains unchanged. You can't
2796 change a policy's type.
2797  
2798 This operation can be called only from the organization's management
2799 account.
2800  
2801  
2802  
2803  
2804 =head1 PAGINATORS
2805  
2806 Paginator methods are helpers that repetively call methods that return partial results
2807  
2808 =head2 ListAllAccounts(sub { },[MaxResults => Int, NextToken => Str])
2809  
2810 =head2 ListAllAccounts([MaxResults => Int, NextToken => Str])
2811  
2812  
2813 If passed a sub as first parameter, it will call the sub for each element found in :
2814  
2815 - Accounts, passing the object as the first parameter, and the string 'Accounts' as the second parameter
2816  
2817 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.
2818  
2819  
2820 =head2 ListAllAccountsForParent(sub { },ParentId => Str, [MaxResults => Int, NextToken => Str])
2821  
2822 =head2 ListAllAccountsForParent(ParentId => Str, [MaxResults => Int, NextToken => Str])
2823  
2824  
2825 If passed a sub as first parameter, it will call the sub for each element found in :
2826  
2827 - Accounts, passing the object as the first parameter, and the string 'Accounts' as the second parameter
2828  
2829 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.
2830  
2831  
2832 =head2 ListAllAWSServiceAccessForOrganization(sub { },[MaxResults => Int, NextToken => Str])
2833  
2834 =head2 ListAllAWSServiceAccessForOrganization([MaxResults => Int, NextToken => Str])
2835  
2836  
2837 If passed a sub as first parameter, it will call the sub for each element found in :
2838  
2839 - EnabledServicePrincipals, passing the object as the first parameter, and the string 'EnabledServicePrincipals' as the second parameter
2840  
2841 If not, it will return a a L<Paws::Organizations::ListAWSServiceAccessForOrganizationResponse> 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.
2842  
2843  
2844 =head2 ListAllChildren(sub { },ChildType => Str, ParentId => Str, [MaxResults => Int, NextToken => Str])
2845  
2846 =head2 ListAllChildren(ChildType => Str, ParentId => Str, [MaxResults => Int, NextToken => Str])
2847  
2848  
2849 If passed a sub as first parameter, it will call the sub for each element found in :
2850  
2851 - Children, passing the object as the first parameter, and the string 'Children' as the second parameter
2852  
2853 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.
2854  
2855  
2856 =head2 ListAllCreateAccountStatus(sub { },[MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef]])
2857  
2858 =head2 ListAllCreateAccountStatus([MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef]])
2859  
2860  
2861 If passed a sub as first parameter, it will call the sub for each element found in :
2862  
2863 - CreateAccountStatuses, passing the object as the first parameter, and the string 'CreateAccountStatuses' as the second parameter
2864  
2865 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.
2866  
2867  
2868 =head2 ListAllDelegatedAdministrators(sub { },[MaxResults => Int, NextToken => Str, ServicePrincipal => Str])
2869  
2870 =head2 ListAllDelegatedAdministrators([MaxResults => Int, NextToken => Str, ServicePrincipal => Str])
2871  
2872  
2873 If passed a sub as first parameter, it will call the sub for each element found in :
2874  
2875 - DelegatedAdministrators, passing the object as the first parameter, and the string 'DelegatedAdministrators' as the second parameter
2876  
2877 If not, it will return a a L<Paws::Organizations::ListDelegatedAdministratorsResponse> 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.
2878  
2879  
2880 =head2 ListAllDelegatedServicesForAccount(sub { },AccountId => Str, [MaxResults => Int, NextToken => Str])
2881  
2882 =head2 ListAllDelegatedServicesForAccount(AccountId => Str, [MaxResults => Int, NextToken => Str])
2883  
2884  
2885 If passed a sub as first parameter, it will call the sub for each element found in :
2886  
2887 - DelegatedServices, passing the object as the first parameter, and the string 'DelegatedServices' as the second parameter
2888  
2889 If not, it will return a a L<Paws::Organizations::ListDelegatedServicesForAccountResponse> 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.
2890  
2891  
2892 =head2 ListAllHandshakesForAccount(sub { },[Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
2893  
2894 =head2 ListAllHandshakesForAccount([Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
2895  
2896  
2897 If passed a sub as first parameter, it will call the sub for each element found in :
2898  
2899 - Handshakes, passing the object as the first parameter, and the string 'Handshakes' as the second parameter
2900  
2901 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.
2902  
2903  
2904 =head2 ListAllHandshakesForOrganization(sub { },[Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
2905  
2906 =head2 ListAllHandshakesForOrganization([Filter => L<Paws::Organizations::HandshakeFilter>, MaxResults => Int, NextToken => Str])
2907  
2908  
2909 If passed a sub as first parameter, it will call the sub for each element found in :
2910  
2911 - Handshakes, passing the object as the first parameter, and the string 'Handshakes' as the second parameter
2912  
2913 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.
2914  
2915  
2916 =head2 ListAllOrganizationalUnitsForParent(sub { },ParentId => Str, [MaxResults => Int, NextToken => Str])
2917  
2918 =head2 ListAllOrganizationalUnitsForParent(ParentId => Str, [MaxResults => Int, NextToken => Str])
2919  
2920  
2921 If passed a sub as first parameter, it will call the sub for each element found in :
2922  
2923 - OrganizationalUnits, passing the object as the first parameter, and the string 'OrganizationalUnits' as the second parameter
2924  
2925 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.
2926  
2927  
2928 =head2 ListAllParents(sub { },ChildId => Str, [MaxResults => Int, NextToken => Str])
2929  
2930 =head2 ListAllParents(ChildId => Str, [MaxResults => Int, NextToken => Str])
2931  
2932  
2933 If passed a sub as first parameter, it will call the sub for each element found in :
2934  
2935 - Parents, passing the object as the first parameter, and the string 'Parents' as the second parameter
2936  
2937 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.
2938  
2939  
2940 =head2 ListAllPolicies(sub { },Filter => Str, [MaxResults => Int, NextToken => Str])
2941  
2942 =head2 ListAllPolicies(Filter => Str, [MaxResults => Int, NextToken => Str])
2943  
2944  
2945 If passed a sub as first parameter, it will call the sub for each element found in :
2946  
2947 - Policies, passing the object as the first parameter, and the string 'Policies' as the second parameter
2948  
2949 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.
2950  
2951  
2952 =head2 ListAllPoliciesForTarget(sub { },Filter => Str, TargetId => Str, [MaxResults => Int, NextToken => Str])
2953  
2954 =head2 ListAllPoliciesForTarget(Filter => Str, TargetId => Str, [MaxResults => Int, NextToken => Str])
2955  
2956  
2957 If passed a sub as first parameter, it will call the sub for each element found in :
2958  
2959 - Policies, passing the object as the first parameter, and the string 'Policies' as the second parameter
2960  
2961 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.
2962  
2963  
2964 =head2 ListAllRoots(sub { },[MaxResults => Int, NextToken => Str])
2965  
2966 =head2 ListAllRoots([MaxResults => Int, NextToken => Str])
2967  
2968  
2969 If passed a sub as first parameter, it will call the sub for each element found in :
2970  
2971 - Roots, passing the object as the first parameter, and the string 'Roots' as the second parameter
2972  
2973 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.
2974  
2975  
2976 =head2 ListAllTagsForResource(sub { },ResourceId => Str, [NextToken => Str])
2977  
2978 =head2 ListAllTagsForResource(ResourceId => Str, [NextToken => Str])
2979  
2980  
2981 If passed a sub as first parameter, it will call the sub for each element found in :
2982  
2983 - Tags, passing the object as the first parameter, and the string 'Tags' as the second parameter
2984  
2985 If not, it will return a a L<Paws::Organizations::ListTagsForResourceResponse> 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.
2986  
2987  
2988 =head2 ListAllTargetsForPolicy(sub { },PolicyId => Str, [MaxResults => Int, NextToken => Str])
2989  
2990 =head2 ListAllTargetsForPolicy(PolicyId => Str, [MaxResults => Int, NextToken => Str])
2991  
2992  
2993 If passed a sub as first parameter, it will call the sub for each element found in :
2994  
2995 - Targets, passing the object as the first parameter, and the string 'Targets' as the second parameter
2996  
2997 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.
2998  
2999  
3000  
3001  
3002  
3003 =head1 SEE ALSO
3004  
3005 This service class forms part of L<Paws>
3006  
3007 =head1 BUGS and CONTRIBUTIONS
3008  
3009 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
3010  
3011 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
3012  
3013 =cut
3014