File Coverage

blib/lib/Paws/Support.pm
Criterion Covered Total %
statement 10 89 11.2
branch 0 8 0.0
condition n/a
subroutine 4 23 17.3
pod 16 21 76.1
total 30 141 21.2


line stmt bran cond sub pod time code
1             package Paws::Support;
2 1     1   7783 use Moose;
  1     2   4  
  1         11  
  2         1661  
  2         5  
  2         14  
3 2     2 0 9 sub service { 'support' }
4 0     0 0 0 sub version { '2013-04-15' }
5 0     0 0 0 sub target_prefix { 'AWSSupport_20130415' }
6 0     0 0 0 sub json_version { "1.1" }
7             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8             has retry => (is => 'ro', isa => 'HashRef', default => sub {
9             { base => 'rand', type => 'exponential', growth_factor => 2 }
10             });
11             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12             ] });
13              
14             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller', 'Paws::Net::JsonResponse';
15              
16            
17             sub AddAttachmentsToSet {
18 0     0 1 0 my $self = shift;
19 0         0 my $call_object = $self->new_with_coercions('Paws::Support::AddAttachmentsToSet', @_);
20 0         0 return $self->caller->do_call($self, $call_object);
21             }
22             sub AddCommunicationToCase {
23 0     0 1 0 my $self = shift;
24 0         0 my $call_object = $self->new_with_coercions('Paws::Support::AddCommunicationToCase', @_);
25 0         0 return $self->caller->do_call($self, $call_object);
26             }
27             sub CreateCase {
28 0     0 1 0 my $self = shift;
29 0         0 my $call_object = $self->new_with_coercions('Paws::Support::CreateCase', @_);
30 0         0 return $self->caller->do_call($self, $call_object);
31             }
32             sub DescribeAttachment {
33 0     0 1 0 my $self = shift;
34 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeAttachment', @_);
35 0         0 return $self->caller->do_call($self, $call_object);
36             }
37             sub DescribeCases {
38 0     0 1 0 my $self = shift;
39 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeCases', @_);
40 0         0 return $self->caller->do_call($self, $call_object);
41             }
42             sub DescribeCommunications {
43 0     0 1 0 my $self = shift;
44 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeCommunications', @_);
45 0         0 return $self->caller->do_call($self, $call_object);
46             }
47             sub DescribeServices {
48 0     0 1 0 my $self = shift;
49 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeServices', @_);
50 0         0 return $self->caller->do_call($self, $call_object);
51             }
52             sub DescribeSeverityLevels {
53 0     0 1 0 my $self = shift;
54 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeSeverityLevels', @_);
55 0         0 return $self->caller->do_call($self, $call_object);
56             }
57             sub DescribeTrustedAdvisorCheckRefreshStatuses {
58 0     0 1 0 my $self = shift;
59 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeTrustedAdvisorCheckRefreshStatuses', @_);
60 0         0 return $self->caller->do_call($self, $call_object);
61             }
62             sub DescribeTrustedAdvisorCheckResult {
63 0     0 1 0 my $self = shift;
64 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeTrustedAdvisorCheckResult', @_);
65 0         0 return $self->caller->do_call($self, $call_object);
66             }
67             sub DescribeTrustedAdvisorChecks {
68 0     0 1 0 my $self = shift;
69 0         0 my $call_object = $self->new_with_coercions('Paws::Support::DescribeTrustedAdvisorChecks', @_);
70 0         0 return $self->caller->do_call($self, $call_object);
71             }
72             sub DescribeTrustedAdvisorCheckSummaries {
73 1     1 1 252 my $self = shift;
74 1         4 my $call_object = $self->new_with_coercions('Paws::Support::DescribeTrustedAdvisorCheckSummaries', @_);
75 1         487 return $self->caller->do_call($self, $call_object);
76             }
77             sub RefreshTrustedAdvisorCheck {
78 0     0 1   my $self = shift;
79 0           my $call_object = $self->new_with_coercions('Paws::Support::RefreshTrustedAdvisorCheck', @_);
80 0           return $self->caller->do_call($self, $call_object);
81             }
82             sub ResolveCase {
83 0     0 1   my $self = shift;
84 0           my $call_object = $self->new_with_coercions('Paws::Support::ResolveCase', @_);
85 0           return $self->caller->do_call($self, $call_object);
86             }
87            
88             sub DescribeAllCases {
89 0     0 1   my $self = shift;
90              
91 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
92 0           my $result = $self->DescribeCases(@_);
93 0           my $next_result = $result;
94              
95 0 0         if (not defined $callback) {
96 0           while ($next_result->nextToken) {
97 0           $next_result = $self->DescribeCases(@_, nextToken => $next_result->nextToken);
98 0           push @{ $result->cases }, @{ $next_result->cases };
  0            
  0            
99             }
100 0           return $result;
101             } else {
102 0           while ($result->nextToken) {
103 0           $callback->($_ => 'cases') foreach (@{ $result->cases });
  0            
104 0           $result = $self->DescribeCases(@_, nextToken => $result->nextToken);
105             }
106 0           $callback->($_ => 'cases') foreach (@{ $result->cases });
  0            
107             }
108              
109             return undef
110 0           }
111             sub DescribeAllCommunications {
112 0     0 1   my $self = shift;
113              
114 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
115 0           my $result = $self->DescribeCommunications(@_);
116 0           my $next_result = $result;
117              
118 0 0         if (not defined $callback) {
119 0           while ($next_result->nextToken) {
120 0           $next_result = $self->DescribeCommunications(@_, nextToken => $next_result->nextToken);
121 0           push @{ $result->communications }, @{ $next_result->communications };
  0            
  0            
122             }
123 0           return $result;
124             } else {
125 0           while ($result->nextToken) {
126 0           $callback->($_ => 'communications') foreach (@{ $result->communications });
  0            
127 0           $result = $self->DescribeCommunications(@_, nextToken => $result->nextToken);
128             }
129 0           $callback->($_ => 'communications') foreach (@{ $result->communications });
  0            
130             }
131              
132             return undef
133 0           }
134              
135              
136 0     0 0   sub operations { qw/AddAttachmentsToSet AddCommunicationToCase CreateCase DescribeAttachment DescribeCases DescribeCommunications DescribeServices DescribeSeverityLevels DescribeTrustedAdvisorCheckRefreshStatuses DescribeTrustedAdvisorCheckResult DescribeTrustedAdvisorChecks DescribeTrustedAdvisorCheckSummaries RefreshTrustedAdvisorCheck ResolveCase / }
137              
138             1;
139              
140             ### main pod documentation begin ###
141              
142             =head1 NAME
143              
144             Paws::Support - Perl Interface to AWS AWS Support
145              
146             =head1 SYNOPSIS
147              
148             use Paws;
149              
150             my $obj = Paws->service('Support');
151             my $res = $obj->Method(
152             Arg1 => $val1,
153             Arg2 => [ 'V1', 'V2' ],
154             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
155             # of the arguments type
156             Arg3 => { Att1 => 'Val1' },
157             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
158             # the constructor of the arguments type
159             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
160             );
161              
162             =head1 DESCRIPTION
163              
164             AWS Support
165              
166             The AWS Support API reference is intended for programmers who need
167             detailed information about the AWS Support operations and data types.
168             This service enables you to manage your AWS Support cases
169             programmatically. It uses HTTP methods that return results in JSON
170             format.
171              
172             The AWS Support service also exposes a set of Trusted Advisor features.
173             You can retrieve a list of checks and their descriptions, get check
174             results, specify checks to refresh, and get the refresh status of
175             checks.
176              
177             The following list describes the AWS Support case management
178             operations:
179              
180             =over
181              
182             =item *
183              
184             B<Service names, issue categories, and available severity levels. >The
185             DescribeServices and DescribeSeverityLevels operations return AWS
186             service names, service codes, service categories, and problem severity
187             levels. You use these values when you call the CreateCase operation.
188              
189             =item *
190              
191             B<Case creation, case details, and case resolution.> The CreateCase,
192             DescribeCases, DescribeAttachment, and ResolveCase operations create
193             AWS Support cases, retrieve information about cases, and resolve cases.
194              
195             =item *
196              
197             B<Case communication.> The DescribeCommunications,
198             AddCommunicationToCase, and AddAttachmentsToSet operations retrieve and
199             add communications and attachments to AWS Support cases.
200              
201             =back
202              
203             The following list describes the operations available from the AWS
204             Support service for Trusted Advisor:
205              
206             =over
207              
208             =item *
209              
210             DescribeTrustedAdvisorChecks returns the list of checks that run
211             against your AWS resources.
212              
213             =item *
214              
215             Using the C<checkId> for a specific check returned by
216             DescribeTrustedAdvisorChecks, you can call
217             DescribeTrustedAdvisorCheckResult to obtain the results for the check
218             you specified.
219              
220             =item *
221              
222             DescribeTrustedAdvisorCheckSummaries returns summarized results for one
223             or more Trusted Advisor checks.
224              
225             =item *
226              
227             RefreshTrustedAdvisorCheck requests that Trusted Advisor rerun a
228             specified check.
229              
230             =item *
231              
232             DescribeTrustedAdvisorCheckRefreshStatuses reports the refresh status
233             of one or more checks.
234              
235             =back
236              
237             For authentication of requests, AWS Support uses Signature Version 4
238             Signing Process.
239              
240             See About the AWS Support API in the I<AWS Support User Guide> for
241             information about how to use this service to create and manage your
242             support cases, and how to call Trusted Advisor for results of checks on
243             your resources.
244              
245             =head1 METHODS
246              
247             =head2 AddAttachmentsToSet(Attachments => ArrayRef[L<Paws::Support::Attachment>], [AttachmentSetId => Str])
248              
249             Each argument is described in detail in: L<Paws::Support::AddAttachmentsToSet>
250              
251             Returns: a L<Paws::Support::AddAttachmentsToSetResponse> instance
252              
253             Adds one or more attachments to an attachment set. If an
254             C<attachmentSetId> is not specified, a new attachment set is created,
255             and the ID of the set is returned in the response. If an
256             C<attachmentSetId> is specified, the attachments are added to the
257             specified set, if it exists.
258              
259             An attachment set is a temporary container for attachments that are to
260             be added to a case or case communication. The set is available for one
261             hour after it is created; the C<expiryTime> returned in the response
262             indicates when the set expires. The maximum number of attachments in a
263             set is 3, and the maximum size of any attachment in the set is 5 MB.
264              
265              
266             =head2 AddCommunicationToCase(CommunicationBody => Str, [AttachmentSetId => Str, CaseId => Str, CcEmailAddresses => ArrayRef[Str|Undef]])
267              
268             Each argument is described in detail in: L<Paws::Support::AddCommunicationToCase>
269              
270             Returns: a L<Paws::Support::AddCommunicationToCaseResponse> instance
271              
272             Adds additional customer communication to an AWS Support case. You use
273             the C<caseId> value to identify the case to add communication to. You
274             can list a set of email addresses to copy on the communication using
275             the C<ccEmailAddresses> value. The C<communicationBody> value contains
276             the text of the communication.
277              
278             The response indicates the success or failure of the request.
279              
280             This operation implements a subset of the features of the AWS Support
281             Center.
282              
283              
284             =head2 CreateCase(CommunicationBody => Str, Subject => Str, [AttachmentSetId => Str, CategoryCode => Str, CcEmailAddresses => ArrayRef[Str|Undef], IssueType => Str, Language => Str, ServiceCode => Str, SeverityCode => Str])
285              
286             Each argument is described in detail in: L<Paws::Support::CreateCase>
287              
288             Returns: a L<Paws::Support::CreateCaseResponse> instance
289              
290             Creates a new case in the AWS Support Center. This operation is modeled
291             on the behavior of the AWS Support Center Create Case page. Its
292             parameters require you to specify the following information:
293              
294             =over
295              
296             =item *
297              
298             B<issueType.> The type of issue for the case. You can specify either
299             "customer-service" or "technical." If you do not indicate a value, the
300             default is "technical."
301              
302             =item *
303              
304             B<serviceCode.> The code for an AWS service. You obtain the
305             C<serviceCode> by calling DescribeServices.
306              
307             =item *
308              
309             B<categoryCode.> The category for the service defined for the
310             C<serviceCode> value. You also obtain the category code for a service
311             by calling DescribeServices. Each AWS service defines its own set of
312             category codes.
313              
314             =item *
315              
316             B<severityCode.> A value that indicates the urgency of the case, which
317             in turn determines the response time according to your service level
318             agreement with AWS Support. You obtain the SeverityCode by calling
319             DescribeSeverityLevels.
320              
321             =item *
322              
323             B<subject.> The B<Subject> field on the AWS Support Center Create Case
324             page.
325              
326             =item *
327              
328             B<communicationBody.> The B<Description> field on the AWS Support
329             Center Create Case page.
330              
331             =item *
332              
333             B<attachmentSetId.> The ID of a set of attachments that has been
334             created by using AddAttachmentsToSet.
335              
336             =item *
337              
338             B<language.> The human language in which AWS Support handles the case.
339             English and Japanese are currently supported.
340              
341             =item *
342              
343             B<ccEmailAddresses.> The AWS Support Center B<CC> field on the Create
344             Case page. You can list email addresses to be copied on any
345             correspondence about the case. The account that opens the case is
346             already identified by passing the AWS Credentials in the HTTP POST
347             method or in a method or function call from one of the programming
348             languages supported by an AWS SDK.
349              
350             =back
351              
352             To add additional communication or attachments to an existing case, use
353             AddCommunicationToCase.
354              
355             A successful CreateCase request returns an AWS Support case number.
356             Case numbers are used by the DescribeCases operation to retrieve
357             existing AWS Support cases.
358              
359              
360             =head2 DescribeAttachment(AttachmentId => Str)
361              
362             Each argument is described in detail in: L<Paws::Support::DescribeAttachment>
363              
364             Returns: a L<Paws::Support::DescribeAttachmentResponse> instance
365              
366             Returns the attachment that has the specified ID. Attachment IDs are
367             generated by the case management system when you add an attachment to a
368             case or case communication. Attachment IDs are returned in the
369             AttachmentDetails objects that are returned by the
370             DescribeCommunications operation.
371              
372              
373             =head2 DescribeCases([AfterTime => Str, BeforeTime => Str, CaseIdList => ArrayRef[Str|Undef], DisplayId => Str, IncludeCommunications => Bool, IncludeResolvedCases => Bool, Language => Str, MaxResults => Int, NextToken => Str])
374              
375             Each argument is described in detail in: L<Paws::Support::DescribeCases>
376              
377             Returns: a L<Paws::Support::DescribeCasesResponse> instance
378              
379             Returns a list of cases that you specify by passing one or more case
380             IDs. In addition, you can filter the cases by date by setting values
381             for the C<afterTime> and C<beforeTime> request parameters. You can set
382             values for the C<includeResolvedCases> and C<includeCommunications>
383             request parameters to control how much information is returned.
384              
385             Case data is available for 12 months after creation. If a case was
386             created more than 12 months ago, a request for data might cause an
387             error.
388              
389             The response returns the following in JSON format:
390              
391             =over
392              
393             =item *
394              
395             One or more CaseDetails data types.
396              
397             =item *
398              
399             One or more C<nextToken> values, which specify where to paginate the
400             returned records represented by the C<CaseDetails> objects.
401              
402             =back
403              
404              
405              
406             =head2 DescribeCommunications(CaseId => Str, [AfterTime => Str, BeforeTime => Str, MaxResults => Int, NextToken => Str])
407              
408             Each argument is described in detail in: L<Paws::Support::DescribeCommunications>
409              
410             Returns: a L<Paws::Support::DescribeCommunicationsResponse> instance
411              
412             Returns communications (and attachments) for one or more support cases.
413             You can use the C<afterTime> and C<beforeTime> parameters to filter by
414             date. You can use the C<caseId> parameter to restrict the results to a
415             particular case.
416              
417             Case data is available for 12 months after creation. If a case was
418             created more than 12 months ago, a request for data might cause an
419             error.
420              
421             You can use the C<maxResults> and C<nextToken> parameters to control
422             the pagination of the result set. Set C<maxResults> to the number of
423             cases you want displayed on each page, and use C<nextToken> to specify
424             the resumption of pagination.
425              
426              
427             =head2 DescribeServices([Language => Str, ServiceCodeList => ArrayRef[Str|Undef]])
428              
429             Each argument is described in detail in: L<Paws::Support::DescribeServices>
430              
431             Returns: a L<Paws::Support::DescribeServicesResponse> instance
432              
433             Returns the current list of AWS services and a list of service
434             categories that applies to each one. You then use service names and
435             categories in your CreateCase requests. Each AWS service has its own
436             set of categories.
437              
438             The service codes and category codes correspond to the values that are
439             displayed in the B<Service> and B<Category> drop-down lists on the AWS
440             Support Center Create Case page. The values in those fields, however,
441             do not necessarily match the service codes and categories returned by
442             the C<DescribeServices> request. Always use the service codes and
443             categories obtained programmatically. This practice ensures that you
444             always have the most recent set of service and category codes.
445              
446              
447             =head2 DescribeSeverityLevels([Language => Str])
448              
449             Each argument is described in detail in: L<Paws::Support::DescribeSeverityLevels>
450              
451             Returns: a L<Paws::Support::DescribeSeverityLevelsResponse> instance
452              
453             Returns the list of severity levels that you can assign to an AWS
454             Support case. The severity level for a case is also a field in the
455             CaseDetails data type included in any CreateCase request.
456              
457              
458             =head2 DescribeTrustedAdvisorCheckRefreshStatuses(CheckIds => ArrayRef[Str|Undef])
459              
460             Each argument is described in detail in: L<Paws::Support::DescribeTrustedAdvisorCheckRefreshStatuses>
461              
462             Returns: a L<Paws::Support::DescribeTrustedAdvisorCheckRefreshStatusesResponse> instance
463              
464             Returns the refresh status of the Trusted Advisor checks that have the
465             specified check IDs. Check IDs can be obtained by calling
466             DescribeTrustedAdvisorChecks.
467              
468             Some checks are refreshed automatically, and their refresh statuses
469             cannot be retrieved by using this operation. Use of the
470             C<DescribeTrustedAdvisorCheckRefreshStatuses> operation for these
471             checks causes an C<InvalidParameterValue> error.
472              
473              
474             =head2 DescribeTrustedAdvisorCheckResult(CheckId => Str, [Language => Str])
475              
476             Each argument is described in detail in: L<Paws::Support::DescribeTrustedAdvisorCheckResult>
477              
478             Returns: a L<Paws::Support::DescribeTrustedAdvisorCheckResultResponse> instance
479              
480             Returns the results of the Trusted Advisor check that has the specified
481             check ID. Check IDs can be obtained by calling
482             DescribeTrustedAdvisorChecks.
483              
484             The response contains a TrustedAdvisorCheckResult object, which
485             contains these three objects:
486              
487             =over
488              
489             =item *
490              
491             TrustedAdvisorCategorySpecificSummary
492              
493             =item *
494              
495             TrustedAdvisorResourceDetail
496              
497             =item *
498              
499             TrustedAdvisorResourcesSummary
500              
501             =back
502              
503             In addition, the response contains these fields:
504              
505             =over
506              
507             =item *
508              
509             B<status.> The alert status of the check: "ok" (green), "warning"
510             (yellow), "error" (red), or "not_available".
511              
512             =item *
513              
514             B<timestamp.> The time of the last refresh of the check.
515              
516             =item *
517              
518             B<checkId.> The unique identifier for the check.
519              
520             =back
521              
522              
523              
524             =head2 DescribeTrustedAdvisorChecks(Language => Str)
525              
526             Each argument is described in detail in: L<Paws::Support::DescribeTrustedAdvisorChecks>
527              
528             Returns: a L<Paws::Support::DescribeTrustedAdvisorChecksResponse> instance
529              
530             Returns information about all available Trusted Advisor checks,
531             including name, ID, category, description, and metadata. You must
532             specify a language code; English ("en") and Japanese ("ja") are
533             currently supported. The response contains a
534             TrustedAdvisorCheckDescription for each check.
535              
536              
537             =head2 DescribeTrustedAdvisorCheckSummaries(CheckIds => ArrayRef[Str|Undef])
538              
539             Each argument is described in detail in: L<Paws::Support::DescribeTrustedAdvisorCheckSummaries>
540              
541             Returns: a L<Paws::Support::DescribeTrustedAdvisorCheckSummariesResponse> instance
542              
543             Returns the summaries of the results of the Trusted Advisor checks that
544             have the specified check IDs. Check IDs can be obtained by calling
545             DescribeTrustedAdvisorChecks.
546              
547             The response contains an array of TrustedAdvisorCheckSummary objects.
548              
549              
550             =head2 RefreshTrustedAdvisorCheck(CheckId => Str)
551              
552             Each argument is described in detail in: L<Paws::Support::RefreshTrustedAdvisorCheck>
553              
554             Returns: a L<Paws::Support::RefreshTrustedAdvisorCheckResponse> instance
555              
556             Requests a refresh of the Trusted Advisor check that has the specified
557             check ID. Check IDs can be obtained by calling
558             DescribeTrustedAdvisorChecks.
559              
560             Some checks are refreshed automatically, and they cannot be refreshed
561             by using this operation. Use of the C<RefreshTrustedAdvisorCheck>
562             operation for these checks causes an C<InvalidParameterValue> error.
563              
564             The response contains a TrustedAdvisorCheckRefreshStatus object, which
565             contains these fields:
566              
567             =over
568              
569             =item *
570              
571             B<status.> The refresh status of the check: "none", "enqueued",
572             "processing", "success", or "abandoned".
573              
574             =item *
575              
576             B<millisUntilNextRefreshable.> The amount of time, in milliseconds,
577             until the check is eligible for refresh.
578              
579             =item *
580              
581             B<checkId.> The unique identifier for the check.
582              
583             =back
584              
585              
586              
587             =head2 ResolveCase([CaseId => Str])
588              
589             Each argument is described in detail in: L<Paws::Support::ResolveCase>
590              
591             Returns: a L<Paws::Support::ResolveCaseResponse> instance
592              
593             Takes a C<caseId> and returns the initial state of the case along with
594             the state of the case after the call to ResolveCase completed.
595              
596              
597              
598              
599             =head1 PAGINATORS
600              
601             Paginator methods are helpers that repetively call methods that return partial results
602              
603             =head2 DescribeAllCases(sub { },[AfterTime => Str, BeforeTime => Str, CaseIdList => ArrayRef[Str|Undef], DisplayId => Str, IncludeCommunications => Bool, IncludeResolvedCases => Bool, Language => Str, MaxResults => Int, NextToken => Str])
604              
605             =head2 DescribeAllCases([AfterTime => Str, BeforeTime => Str, CaseIdList => ArrayRef[Str|Undef], DisplayId => Str, IncludeCommunications => Bool, IncludeResolvedCases => Bool, Language => Str, MaxResults => Int, NextToken => Str])
606              
607              
608             If passed a sub as first parameter, it will call the sub for each element found in :
609              
610             - cases, passing the object as the first parameter, and the string 'cases' as the second parameter
611              
612             If not, it will return a a L<Paws::Support::DescribeCasesResponse> 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.
613              
614              
615             =head2 DescribeAllCommunications(sub { },CaseId => Str, [AfterTime => Str, BeforeTime => Str, MaxResults => Int, NextToken => Str])
616              
617             =head2 DescribeAllCommunications(CaseId => Str, [AfterTime => Str, BeforeTime => Str, MaxResults => Int, NextToken => Str])
618              
619              
620             If passed a sub as first parameter, it will call the sub for each element found in :
621              
622             - communications, passing the object as the first parameter, and the string 'communications' as the second parameter
623              
624             If not, it will return a a L<Paws::Support::DescribeCommunicationsResponse> 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.
625              
626              
627              
628              
629              
630             =head1 SEE ALSO
631              
632             This service class forms part of L<Paws>
633              
634             =head1 BUGS and CONTRIBUTIONS
635              
636             The source code is located here: https://github.com/pplu/aws-sdk-perl
637              
638             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
639              
640             =cut
641