blib/lib/Paws/AccessAnalyzer.pm untested

filter: Statementstmt 0.0% 0 / 257 Branchbran 0.0% 0 / 32 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 42 Podpod 0.0% 0 / 41 totaltotal 0.0% 0 / 372 CC 17 SCAR 18.1
CC
17
Cov
0%
ListAllAccessPreviewFindings
12.0
ListAllAccessPreviews
12.0
ListAllAnalyzedResources
12.0
CRAP 6.1
1 package Paws::AccessAnalyzer;
2 use Moose;
3 sub service { 'access-analyzer' }
4 sub signing_name { 'access-analyzer' }
5 sub version { '2019-11-01' }
6 sub flattened_arrays { 0 }
7 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 has retry => (is => 'ro', isa => 'HashRef', default => sub {
9 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 });
11 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12 ] });
13  
14 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller';
15  
16
17 sub ApplyArchiveRule {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ApplyArchiveRule', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub CancelPolicyGeneration {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::CancelPolicyGeneration', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub CreateAccessPreview {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::CreateAccessPreview', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub CreateAnalyzer {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::CreateAnalyzer', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub CreateArchiveRule {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::CreateArchiveRule', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub DeleteAnalyzer {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::DeleteAnalyzer', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub DeleteArchiveRule {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::DeleteArchiveRule', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub GetAccessPreview {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::GetAccessPreview', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub GetAnalyzedResource {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::GetAnalyzedResource', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub GetAnalyzer {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::GetAnalyzer', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub GetArchiveRule {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::GetArchiveRule', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub GetFinding {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::GetFinding', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub GetGeneratedPolicy {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::GetGeneratedPolicy', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub ListAccessPreviewFindings {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListAccessPreviewFindings', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub ListAccessPreviews {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListAccessPreviews', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92 sub ListAnalyzedResources {
93 my $self = shift;
94 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListAnalyzedResources', @_);
95 return $self->caller->do_call($self, $call_object);
96 }
97 sub ListAnalyzers {
98 my $self = shift;
99 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListAnalyzers', @_);
100 return $self->caller->do_call($self, $call_object);
101 }
102 sub ListArchiveRules {
103 my $self = shift;
104 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListArchiveRules', @_);
105 return $self->caller->do_call($self, $call_object);
106 }
107 sub ListFindings {
108 my $self = shift;
109 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListFindings', @_);
110 return $self->caller->do_call($self, $call_object);
111 }
112 sub ListPolicyGenerations {
113 my $self = shift;
114 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListPolicyGenerations', @_);
115 return $self->caller->do_call($self, $call_object);
116 }
117 sub ListTagsForResource {
118 my $self = shift;
119 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ListTagsForResource', @_);
120 return $self->caller->do_call($self, $call_object);
121 }
122 sub StartPolicyGeneration {
123 my $self = shift;
124 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::StartPolicyGeneration', @_);
125 return $self->caller->do_call($self, $call_object);
126 }
127 sub StartResourceScan {
128 my $self = shift;
129 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::StartResourceScan', @_);
130 return $self->caller->do_call($self, $call_object);
131 }
132 sub TagResource {
133 my $self = shift;
134 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::TagResource', @_);
135 return $self->caller->do_call($self, $call_object);
136 }
137 sub UntagResource {
138 my $self = shift;
139 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::UntagResource', @_);
140 return $self->caller->do_call($self, $call_object);
141 }
142 sub UpdateArchiveRule {
143 my $self = shift;
144 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::UpdateArchiveRule', @_);
145 return $self->caller->do_call($self, $call_object);
146 }
147 sub UpdateFindings {
148 my $self = shift;
149 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::UpdateFindings', @_);
150 return $self->caller->do_call($self, $call_object);
151 }
152 sub ValidatePolicy {
153 my $self = shift;
154 my $call_object = $self->new_with_coercions('Paws::AccessAnalyzer::ValidatePolicy', @_);
155 return $self->caller->do_call($self, $call_object);
156 }
157
158 sub ListAllAccessPreviewFindings {
159 my $self = shift;
160  
161 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
162 my $result = $self->ListAccessPreviewFindings(@_);
163 my $next_result = $result;
164  
165 if (not defined $callback) {
166 while ($next_result->nextToken) {
167 $next_result = $self->ListAccessPreviewFindings(@_, nextToken => $next_result->nextToken);
168 push @{ $result->findings }, @{ $next_result->findings };
169 }
170 return $result;
171 } else {
172 while ($result->nextToken) {
173 $callback->($_ => 'findings') foreach (@{ $result->findings });
174 $result = $self->ListAccessPreviewFindings(@_, nextToken => $result->nextToken);
175 }
176 $callback->($_ => 'findings') foreach (@{ $result->findings });
177 }
178  
179 return undef
180 }
181 sub ListAllAccessPreviews {
182 my $self = shift;
183  
184 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
185 my $result = $self->ListAccessPreviews(@_);
186 my $next_result = $result;
187  
188 if (not defined $callback) {
189 while ($next_result->nextToken) {
190 $next_result = $self->ListAccessPreviews(@_, nextToken => $next_result->nextToken);
191 push @{ $result->accessPreviews }, @{ $next_result->accessPreviews };
192 }
193 return $result;
194 } else {
195 while ($result->nextToken) {
196 $callback->($_ => 'accessPreviews') foreach (@{ $result->accessPreviews });
197 $result = $self->ListAccessPreviews(@_, nextToken => $result->nextToken);
198 }
199 $callback->($_ => 'accessPreviews') foreach (@{ $result->accessPreviews });
200 }
201  
202 return undef
203 }
204 sub ListAllAnalyzedResources {
205 my $self = shift;
206  
207 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
208 my $result = $self->ListAnalyzedResources(@_);
209 my $next_result = $result;
210  
211 if (not defined $callback) {
212 while ($next_result->nextToken) {
213 $next_result = $self->ListAnalyzedResources(@_, nextToken => $next_result->nextToken);
214 push @{ $result->analyzedResources }, @{ $next_result->analyzedResources };
215 }
216 return $result;
217 } else {
218 while ($result->nextToken) {
219 $callback->($_ => 'analyzedResources') foreach (@{ $result->analyzedResources });
220 $result = $self->ListAnalyzedResources(@_, nextToken => $result->nextToken);
221 }
222 $callback->($_ => 'analyzedResources') foreach (@{ $result->analyzedResources });
223 }
224  
225 return undef
226 }
227 sub ListAllAnalyzers {
228 my $self = shift;
229  
230 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
231 my $result = $self->ListAnalyzers(@_);
232 my $next_result = $result;
233  
234 if (not defined $callback) {
235 while ($next_result->nextToken) {
236 $next_result = $self->ListAnalyzers(@_, nextToken => $next_result->nextToken);
237 push @{ $result->analyzers }, @{ $next_result->analyzers };
238 }
239 return $result;
240 } else {
241 while ($result->nextToken) {
242 $callback->($_ => 'analyzers') foreach (@{ $result->analyzers });
243 $result = $self->ListAnalyzers(@_, nextToken => $result->nextToken);
244 }
245 $callback->($_ => 'analyzers') foreach (@{ $result->analyzers });
246 }
247  
248 return undef
249 }
250 sub ListAllArchiveRules {
251 my $self = shift;
252  
253 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
254 my $result = $self->ListArchiveRules(@_);
255 my $next_result = $result;
256  
257 if (not defined $callback) {
258 while ($next_result->nextToken) {
259 $next_result = $self->ListArchiveRules(@_, nextToken => $next_result->nextToken);
260 push @{ $result->archiveRules }, @{ $next_result->archiveRules };
261 }
262 return $result;
263 } else {
264 while ($result->nextToken) {
265 $callback->($_ => 'archiveRules') foreach (@{ $result->archiveRules });
266 $result = $self->ListArchiveRules(@_, nextToken => $result->nextToken);
267 }
268 $callback->($_ => 'archiveRules') foreach (@{ $result->archiveRules });
269 }
270  
271 return undef
272 }
273 sub ListAllFindings {
274 my $self = shift;
275  
276 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
277 my $result = $self->ListFindings(@_);
278 my $next_result = $result;
279  
280 if (not defined $callback) {
281 while ($next_result->nextToken) {
282 $next_result = $self->ListFindings(@_, nextToken => $next_result->nextToken);
283 push @{ $result->findings }, @{ $next_result->findings };
284 }
285 return $result;
286 } else {
287 while ($result->nextToken) {
288 $callback->($_ => 'findings') foreach (@{ $result->findings });
289 $result = $self->ListFindings(@_, nextToken => $result->nextToken);
290 }
291 $callback->($_ => 'findings') foreach (@{ $result->findings });
292 }
293  
294 return undef
295 }
296 sub ListAllPolicyGenerations {
297 my $self = shift;
298  
299 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
300 my $result = $self->ListPolicyGenerations(@_);
301 my $next_result = $result;
302  
303 if (not defined $callback) {
304 while ($next_result->nextToken) {
305 $next_result = $self->ListPolicyGenerations(@_, nextToken => $next_result->nextToken);
306 push @{ $result->policyGenerations }, @{ $next_result->policyGenerations };
307 }
308 return $result;
309 } else {
310 while ($result->nextToken) {
311 $callback->($_ => 'policyGenerations') foreach (@{ $result->policyGenerations });
312 $result = $self->ListPolicyGenerations(@_, nextToken => $result->nextToken);
313 }
314 $callback->($_ => 'policyGenerations') foreach (@{ $result->policyGenerations });
315 }
316  
317 return undef
318 }
319 sub ValidateAllPolicies {
320 my $self = shift;
321  
322 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
323 my $result = $self->ValidatePolicy(@_);
324 my $next_result = $result;
325  
326 if (not defined $callback) {
327 while ($next_result->nextToken) {
328 $next_result = $self->ValidatePolicy(@_, nextToken => $next_result->nextToken);
329 push @{ $result->findings }, @{ $next_result->findings };
330 }
331 return $result;
332 } else {
333 while ($result->nextToken) {
334 $callback->($_ => 'findings') foreach (@{ $result->findings });
335 $result = $self->ValidatePolicy(@_, nextToken => $result->nextToken);
336 }
337 $callback->($_ => 'findings') foreach (@{ $result->findings });
338 }
339  
340 return undef
341 }
342  
343  
344 sub operations { qw/ApplyArchiveRule CancelPolicyGeneration CreateAccessPreview CreateAnalyzer CreateArchiveRule DeleteAnalyzer DeleteArchiveRule GetAccessPreview GetAnalyzedResource GetAnalyzer GetArchiveRule GetFinding GetGeneratedPolicy ListAccessPreviewFindings ListAccessPreviews ListAnalyzedResources ListAnalyzers ListArchiveRules ListFindings ListPolicyGenerations ListTagsForResource StartPolicyGeneration StartResourceScan TagResource UntagResource UpdateArchiveRule UpdateFindings ValidatePolicy / }
345  
346 1;
347  
348 ### main pod documentation begin ###
349  
350 =head1 NAME
351  
352 Paws::AccessAnalyzer - Perl Interface to AWS Access Analyzer
353  
354 =head1 SYNOPSIS
355  
356 use Paws;
357  
358 my $obj = Paws->service('AccessAnalyzer');
359 my $res = $obj->Method(
360 Arg1 => $val1,
361 Arg2 => [ 'V1', 'V2' ],
362 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
363 # of the arguments type
364 Arg3 => { Att1 => 'Val1' },
365 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
366 # the constructor of the arguments type
367 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
368 );
369  
370 =head1 DESCRIPTION
371  
372 AWS IAM Access Analyzer helps identify potential resource-access risks
373 by enabling you to identify any policies that grant access to an
374 external principal. It does this by using logic-based reasoning to
375 analyze resource-based policies in your AWS environment. An external
376 principal can be another AWS account, a root user, an IAM user or role,
377 a federated user, an AWS service, or an anonymous user. You can also
378 use Access Analyzer to preview and validate public and cross-account
379 access to your resources before deploying permissions changes. This
380 guide describes the AWS IAM Access Analyzer operations that you can
381 call programmatically. For general information about Access Analyzer,
382 see AWS IAM Access Analyzer
383 (https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html)
384 in the B<IAM User Guide>.
385  
386 To start using Access Analyzer, you first need to create an analyzer.
387  
388 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/access-analyzer-2019-11-01>
389  
390  
391 =head1 METHODS
392  
393 =head2 ApplyArchiveRule
394  
395 =over
396  
397 =item AnalyzerArn => Str
398  
399 =item RuleName => Str
400  
401 =item [ClientToken => Str]
402  
403  
404 =back
405  
406 Each argument is described in detail in: L<Paws::AccessAnalyzer::ApplyArchiveRule>
407  
408 Returns: nothing
409  
410 Retroactively applies the archive rule to existing findings that meet
411 the archive rule criteria.
412  
413  
414 =head2 CancelPolicyGeneration
415  
416 =over
417  
418 =item JobId => Str
419  
420  
421 =back
422  
423 Each argument is described in detail in: L<Paws::AccessAnalyzer::CancelPolicyGeneration>
424  
425 Returns: a L<Paws::AccessAnalyzer::CancelPolicyGenerationResponse> instance
426  
427 Cancels the requested policy generation.
428  
429  
430 =head2 CreateAccessPreview
431  
432 =over
433  
434 =item AnalyzerArn => Str
435  
436 =item Configurations => L<Paws::AccessAnalyzer::ConfigurationsMap>
437  
438 =item [ClientToken => Str]
439  
440  
441 =back
442  
443 Each argument is described in detail in: L<Paws::AccessAnalyzer::CreateAccessPreview>
444  
445 Returns: a L<Paws::AccessAnalyzer::CreateAccessPreviewResponse> instance
446  
447 Creates an access preview that allows you to preview Access Analyzer
448 findings for your resource before deploying resource permissions.
449  
450  
451 =head2 CreateAnalyzer
452  
453 =over
454  
455 =item AnalyzerName => Str
456  
457 =item Type => Str
458  
459 =item [ArchiveRules => ArrayRef[L<Paws::AccessAnalyzer::InlineArchiveRule>]]
460  
461 =item [ClientToken => Str]
462  
463 =item [Tags => L<Paws::AccessAnalyzer::TagsMap>]
464  
465  
466 =back
467  
468 Each argument is described in detail in: L<Paws::AccessAnalyzer::CreateAnalyzer>
469  
470 Returns: a L<Paws::AccessAnalyzer::CreateAnalyzerResponse> instance
471  
472 Creates an analyzer for your account.
473  
474  
475 =head2 CreateArchiveRule
476  
477 =over
478  
479 =item AnalyzerName => Str
480  
481 =item Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>
482  
483 =item RuleName => Str
484  
485 =item [ClientToken => Str]
486  
487  
488 =back
489  
490 Each argument is described in detail in: L<Paws::AccessAnalyzer::CreateArchiveRule>
491  
492 Returns: nothing
493  
494 Creates an archive rule for the specified analyzer. Archive rules
495 automatically archive new findings that meet the criteria you define
496 when you create the rule.
497  
498 To learn about filter keys that you can use to create an archive rule,
499 see Access Analyzer filter keys
500 (https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-filter-keys.html)
501 in the B<IAM User Guide>.
502  
503  
504 =head2 DeleteAnalyzer
505  
506 =over
507  
508 =item AnalyzerName => Str
509  
510 =item [ClientToken => Str]
511  
512  
513 =back
514  
515 Each argument is described in detail in: L<Paws::AccessAnalyzer::DeleteAnalyzer>
516  
517 Returns: nothing
518  
519 Deletes the specified analyzer. When you delete an analyzer, Access
520 Analyzer is disabled for the account or organization in the current or
521 specific Region. All findings that were generated by the analyzer are
522 deleted. You cannot undo this action.
523  
524  
525 =head2 DeleteArchiveRule
526  
527 =over
528  
529 =item AnalyzerName => Str
530  
531 =item RuleName => Str
532  
533 =item [ClientToken => Str]
534  
535  
536 =back
537  
538 Each argument is described in detail in: L<Paws::AccessAnalyzer::DeleteArchiveRule>
539  
540 Returns: nothing
541  
542 Deletes the specified archive rule.
543  
544  
545 =head2 GetAccessPreview
546  
547 =over
548  
549 =item AccessPreviewId => Str
550  
551 =item AnalyzerArn => Str
552  
553  
554 =back
555  
556 Each argument is described in detail in: L<Paws::AccessAnalyzer::GetAccessPreview>
557  
558 Returns: a L<Paws::AccessAnalyzer::GetAccessPreviewResponse> instance
559  
560 Retrieves information about an access preview for the specified
561 analyzer.
562  
563  
564 =head2 GetAnalyzedResource
565  
566 =over
567  
568 =item AnalyzerArn => Str
569  
570 =item ResourceArn => Str
571  
572  
573 =back
574  
575 Each argument is described in detail in: L<Paws::AccessAnalyzer::GetAnalyzedResource>
576  
577 Returns: a L<Paws::AccessAnalyzer::GetAnalyzedResourceResponse> instance
578  
579 Retrieves information about a resource that was analyzed.
580  
581  
582 =head2 GetAnalyzer
583  
584 =over
585  
586 =item AnalyzerName => Str
587  
588  
589 =back
590  
591 Each argument is described in detail in: L<Paws::AccessAnalyzer::GetAnalyzer>
592  
593 Returns: a L<Paws::AccessAnalyzer::GetAnalyzerResponse> instance
594  
595 Retrieves information about the specified analyzer.
596  
597  
598 =head2 GetArchiveRule
599  
600 =over
601  
602 =item AnalyzerName => Str
603  
604 =item RuleName => Str
605  
606  
607 =back
608  
609 Each argument is described in detail in: L<Paws::AccessAnalyzer::GetArchiveRule>
610  
611 Returns: a L<Paws::AccessAnalyzer::GetArchiveRuleResponse> instance
612  
613 Retrieves information about an archive rule.
614  
615 To learn about filter keys that you can use to create an archive rule,
616 see Access Analyzer filter keys
617 (https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-filter-keys.html)
618 in the B<IAM User Guide>.
619  
620  
621 =head2 GetFinding
622  
623 =over
624  
625 =item AnalyzerArn => Str
626  
627 =item Id => Str
628  
629  
630 =back
631  
632 Each argument is described in detail in: L<Paws::AccessAnalyzer::GetFinding>
633  
634 Returns: a L<Paws::AccessAnalyzer::GetFindingResponse> instance
635  
636 Retrieves information about the specified finding.
637  
638  
639 =head2 GetGeneratedPolicy
640  
641 =over
642  
643 =item JobId => Str
644  
645 =item [IncludeResourcePlaceholders => Bool]
646  
647 =item [IncludeServiceLevelTemplate => Bool]
648  
649  
650 =back
651  
652 Each argument is described in detail in: L<Paws::AccessAnalyzer::GetGeneratedPolicy>
653  
654 Returns: a L<Paws::AccessAnalyzer::GetGeneratedPolicyResponse> instance
655  
656 Retrieves the policy that was generated using C<StartPolicyGeneration>.
657  
658  
659 =head2 ListAccessPreviewFindings
660  
661 =over
662  
663 =item AccessPreviewId => Str
664  
665 =item AnalyzerArn => Str
666  
667 =item [Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>]
668  
669 =item [MaxResults => Int]
670  
671 =item [NextToken => Str]
672  
673  
674 =back
675  
676 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListAccessPreviewFindings>
677  
678 Returns: a L<Paws::AccessAnalyzer::ListAccessPreviewFindingsResponse> instance
679  
680 Retrieves a list of access preview findings generated by the specified
681 access preview.
682  
683  
684 =head2 ListAccessPreviews
685  
686 =over
687  
688 =item AnalyzerArn => Str
689  
690 =item [MaxResults => Int]
691  
692 =item [NextToken => Str]
693  
694  
695 =back
696  
697 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListAccessPreviews>
698  
699 Returns: a L<Paws::AccessAnalyzer::ListAccessPreviewsResponse> instance
700  
701 Retrieves a list of access previews for the specified analyzer.
702  
703  
704 =head2 ListAnalyzedResources
705  
706 =over
707  
708 =item AnalyzerArn => Str
709  
710 =item [MaxResults => Int]
711  
712 =item [NextToken => Str]
713  
714 =item [ResourceType => Str]
715  
716  
717 =back
718  
719 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListAnalyzedResources>
720  
721 Returns: a L<Paws::AccessAnalyzer::ListAnalyzedResourcesResponse> instance
722  
723 Retrieves a list of resources of the specified type that have been
724 analyzed by the specified analyzer..
725  
726  
727 =head2 ListAnalyzers
728  
729 =over
730  
731 =item [MaxResults => Int]
732  
733 =item [NextToken => Str]
734  
735 =item [Type => Str]
736  
737  
738 =back
739  
740 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListAnalyzers>
741  
742 Returns: a L<Paws::AccessAnalyzer::ListAnalyzersResponse> instance
743  
744 Retrieves a list of analyzers.
745  
746  
747 =head2 ListArchiveRules
748  
749 =over
750  
751 =item AnalyzerName => Str
752  
753 =item [MaxResults => Int]
754  
755 =item [NextToken => Str]
756  
757  
758 =back
759  
760 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListArchiveRules>
761  
762 Returns: a L<Paws::AccessAnalyzer::ListArchiveRulesResponse> instance
763  
764 Retrieves a list of archive rules created for the specified analyzer.
765  
766  
767 =head2 ListFindings
768  
769 =over
770  
771 =item AnalyzerArn => Str
772  
773 =item [Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>]
774  
775 =item [MaxResults => Int]
776  
777 =item [NextToken => Str]
778  
779 =item [Sort => L<Paws::AccessAnalyzer::SortCriteria>]
780  
781  
782 =back
783  
784 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListFindings>
785  
786 Returns: a L<Paws::AccessAnalyzer::ListFindingsResponse> instance
787  
788 Retrieves a list of findings generated by the specified analyzer.
789  
790 To learn about filter keys that you can use to retrieve a list of
791 findings, see Access Analyzer filter keys
792 (https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-filter-keys.html)
793 in the B<IAM User Guide>.
794  
795  
796 =head2 ListPolicyGenerations
797  
798 =over
799  
800 =item [MaxResults => Int]
801  
802 =item [NextToken => Str]
803  
804 =item [PrincipalArn => Str]
805  
806  
807 =back
808  
809 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListPolicyGenerations>
810  
811 Returns: a L<Paws::AccessAnalyzer::ListPolicyGenerationsResponse> instance
812  
813 Lists all of the policy generations requested in the last seven days.
814  
815  
816 =head2 ListTagsForResource
817  
818 =over
819  
820 =item ResourceArn => Str
821  
822  
823 =back
824  
825 Each argument is described in detail in: L<Paws::AccessAnalyzer::ListTagsForResource>
826  
827 Returns: a L<Paws::AccessAnalyzer::ListTagsForResourceResponse> instance
828  
829 Retrieves a list of tags applied to the specified resource.
830  
831  
832 =head2 StartPolicyGeneration
833  
834 =over
835  
836 =item PolicyGenerationDetails => L<Paws::AccessAnalyzer::PolicyGenerationDetails>
837  
838 =item [ClientToken => Str]
839  
840 =item [CloudTrailDetails => L<Paws::AccessAnalyzer::CloudTrailDetails>]
841  
842  
843 =back
844  
845 Each argument is described in detail in: L<Paws::AccessAnalyzer::StartPolicyGeneration>
846  
847 Returns: a L<Paws::AccessAnalyzer::StartPolicyGenerationResponse> instance
848  
849 Starts the policy generation request.
850  
851  
852 =head2 StartResourceScan
853  
854 =over
855  
856 =item AnalyzerArn => Str
857  
858 =item ResourceArn => Str
859  
860  
861 =back
862  
863 Each argument is described in detail in: L<Paws::AccessAnalyzer::StartResourceScan>
864  
865 Returns: nothing
866  
867 Immediately starts a scan of the policies applied to the specified
868 resource.
869  
870  
871 =head2 TagResource
872  
873 =over
874  
875 =item ResourceArn => Str
876  
877 =item Tags => L<Paws::AccessAnalyzer::TagsMap>
878  
879  
880 =back
881  
882 Each argument is described in detail in: L<Paws::AccessAnalyzer::TagResource>
883  
884 Returns: a L<Paws::AccessAnalyzer::TagResourceResponse> instance
885  
886 Adds a tag to the specified resource.
887  
888  
889 =head2 UntagResource
890  
891 =over
892  
893 =item ResourceArn => Str
894  
895 =item TagKeys => ArrayRef[Str|Undef]
896  
897  
898 =back
899  
900 Each argument is described in detail in: L<Paws::AccessAnalyzer::UntagResource>
901  
902 Returns: a L<Paws::AccessAnalyzer::UntagResourceResponse> instance
903  
904 Removes a tag from the specified resource.
905  
906  
907 =head2 UpdateArchiveRule
908  
909 =over
910  
911 =item AnalyzerName => Str
912  
913 =item Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>
914  
915 =item RuleName => Str
916  
917 =item [ClientToken => Str]
918  
919  
920 =back
921  
922 Each argument is described in detail in: L<Paws::AccessAnalyzer::UpdateArchiveRule>
923  
924 Returns: nothing
925  
926 Updates the criteria and values for the specified archive rule.
927  
928  
929 =head2 UpdateFindings
930  
931 =over
932  
933 =item AnalyzerArn => Str
934  
935 =item Status => Str
936  
937 =item [ClientToken => Str]
938  
939 =item [Ids => ArrayRef[Str|Undef]]
940  
941 =item [ResourceArn => Str]
942  
943  
944 =back
945  
946 Each argument is described in detail in: L<Paws::AccessAnalyzer::UpdateFindings>
947  
948 Returns: nothing
949  
950 Updates the status for the specified findings.
951  
952  
953 =head2 ValidatePolicy
954  
955 =over
956  
957 =item PolicyDocument => Str
958  
959 =item PolicyType => Str
960  
961 =item [Locale => Str]
962  
963 =item [MaxResults => Int]
964  
965 =item [NextToken => Str]
966  
967  
968 =back
969  
970 Each argument is described in detail in: L<Paws::AccessAnalyzer::ValidatePolicy>
971  
972 Returns: a L<Paws::AccessAnalyzer::ValidatePolicyResponse> instance
973  
974 Requests the validation of a policy and returns a list of findings. The
975 findings help you identify issues and provide actionable
976 recommendations to resolve the issue and enable you to author
977 functional policies that meet security best practices.
978  
979  
980  
981  
982 =head1 PAGINATORS
983  
984 Paginator methods are helpers that repetively call methods that return partial results
985  
986 =head2 ListAllAccessPreviewFindings(sub { },AccessPreviewId => Str, AnalyzerArn => Str, [Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>, MaxResults => Int, NextToken => Str])
987  
988 =head2 ListAllAccessPreviewFindings(AccessPreviewId => Str, AnalyzerArn => Str, [Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>, MaxResults => Int, NextToken => Str])
989  
990  
991 If passed a sub as first parameter, it will call the sub for each element found in :
992  
993 - findings, passing the object as the first parameter, and the string 'findings' as the second parameter
994  
995 If not, it will return a a L<Paws::AccessAnalyzer::ListAccessPreviewFindingsResponse> 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.
996  
997  
998 =head2 ListAllAccessPreviews(sub { },AnalyzerArn => Str, [MaxResults => Int, NextToken => Str])
999  
1000 =head2 ListAllAccessPreviews(AnalyzerArn => Str, [MaxResults => Int, NextToken => Str])
1001  
1002  
1003 If passed a sub as first parameter, it will call the sub for each element found in :
1004  
1005 - accessPreviews, passing the object as the first parameter, and the string 'accessPreviews' as the second parameter
1006  
1007 If not, it will return a a L<Paws::AccessAnalyzer::ListAccessPreviewsResponse> 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.
1008  
1009  
1010 =head2 ListAllAnalyzedResources(sub { },AnalyzerArn => Str, [MaxResults => Int, NextToken => Str, ResourceType => Str])
1011  
1012 =head2 ListAllAnalyzedResources(AnalyzerArn => Str, [MaxResults => Int, NextToken => Str, ResourceType => Str])
1013  
1014  
1015 If passed a sub as first parameter, it will call the sub for each element found in :
1016  
1017 - analyzedResources, passing the object as the first parameter, and the string 'analyzedResources' as the second parameter
1018  
1019 If not, it will return a a L<Paws::AccessAnalyzer::ListAnalyzedResourcesResponse> 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.
1020  
1021  
1022 =head2 ListAllAnalyzers(sub { },[MaxResults => Int, NextToken => Str, Type => Str])
1023  
1024 =head2 ListAllAnalyzers([MaxResults => Int, NextToken => Str, Type => Str])
1025  
1026  
1027 If passed a sub as first parameter, it will call the sub for each element found in :
1028  
1029 - analyzers, passing the object as the first parameter, and the string 'analyzers' as the second parameter
1030  
1031 If not, it will return a a L<Paws::AccessAnalyzer::ListAnalyzersResponse> 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.
1032  
1033  
1034 =head2 ListAllArchiveRules(sub { },AnalyzerName => Str, [MaxResults => Int, NextToken => Str])
1035  
1036 =head2 ListAllArchiveRules(AnalyzerName => Str, [MaxResults => Int, NextToken => Str])
1037  
1038  
1039 If passed a sub as first parameter, it will call the sub for each element found in :
1040  
1041 - archiveRules, passing the object as the first parameter, and the string 'archiveRules' as the second parameter
1042  
1043 If not, it will return a a L<Paws::AccessAnalyzer::ListArchiveRulesResponse> 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.
1044  
1045  
1046 =head2 ListAllFindings(sub { },AnalyzerArn => Str, [Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>, MaxResults => Int, NextToken => Str, Sort => L<Paws::AccessAnalyzer::SortCriteria>])
1047  
1048 =head2 ListAllFindings(AnalyzerArn => Str, [Filter => L<Paws::AccessAnalyzer::FilterCriteriaMap>, MaxResults => Int, NextToken => Str, Sort => L<Paws::AccessAnalyzer::SortCriteria>])
1049  
1050  
1051 If passed a sub as first parameter, it will call the sub for each element found in :
1052  
1053 - findings, passing the object as the first parameter, and the string 'findings' as the second parameter
1054  
1055 If not, it will return a a L<Paws::AccessAnalyzer::ListFindingsResponse> 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.
1056  
1057  
1058 =head2 ListAllPolicyGenerations(sub { },[MaxResults => Int, NextToken => Str, PrincipalArn => Str])
1059  
1060 =head2 ListAllPolicyGenerations([MaxResults => Int, NextToken => Str, PrincipalArn => Str])
1061  
1062  
1063 If passed a sub as first parameter, it will call the sub for each element found in :
1064  
1065 - policyGenerations, passing the object as the first parameter, and the string 'policyGenerations' as the second parameter
1066  
1067 If not, it will return a a L<Paws::AccessAnalyzer::ListPolicyGenerationsResponse> 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.
1068  
1069  
1070 =head2 ValidateAllPolicies(sub { },PolicyDocument => Str, PolicyType => Str, [Locale => Str, MaxResults => Int, NextToken => Str])
1071  
1072 =head2 ValidateAllPolicies(PolicyDocument => Str, PolicyType => Str, [Locale => Str, MaxResults => Int, NextToken => Str])
1073  
1074  
1075 If passed a sub as first parameter, it will call the sub for each element found in :
1076  
1077 - findings, passing the object as the first parameter, and the string 'findings' as the second parameter
1078  
1079 If not, it will return a a L<Paws::AccessAnalyzer::ValidatePolicyResponse> 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.
1080  
1081  
1082  
1083  
1084  
1085 =head1 SEE ALSO
1086  
1087 This service class forms part of L<Paws>
1088  
1089 =head1 BUGS and CONTRIBUTIONS
1090  
1091 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1092  
1093 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1094  
1095 =cut
1096