File Coverage

blib/lib/Paws/RedShift.pm
Criterion Covered Total %
statement 91 469 19.4
branch 0 60 0.0
condition n/a
subroutine 31 84 36.9
pod 78 82 95.1
total 200 695 28.7


line stmt bran cond sub pod time code
1             package Paws::RedShift;
2 1     1   5244 use Moose;
  1     2   2  
  1         9  
  2         3229  
  2         7  
  2         17  
3 34     34 0 136 sub service { 'redshift' }
4 0     0 0 0 sub version { '2012-12-01' }
5 0     0 0 0 sub flattened_arrays { 0 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             ] });
12              
13             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::QueryCaller', 'Paws::Net::XMLResponse';
14              
15            
16             sub AuthorizeClusterSecurityGroupIngress {
17 1     1 1 361 my $self = shift;
18 1         6 my $call_object = $self->new_with_coercions('Paws::RedShift::AuthorizeClusterSecurityGroupIngress', @_);
19 1         810 return $self->caller->do_call($self, $call_object);
20             }
21             sub AuthorizeSnapshotAccess {
22 0     0 1 0 my $self = shift;
23 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::AuthorizeSnapshotAccess', @_);
24 0         0 return $self->caller->do_call($self, $call_object);
25             }
26             sub CopyClusterSnapshot {
27 1     1 1 420 my $self = shift;
28 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::CopyClusterSnapshot', @_);
29 1         953 return $self->caller->do_call($self, $call_object);
30             }
31             sub CreateCluster {
32 1     1 1 1246 my $self = shift;
33 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateCluster', @_);
34 1         3617 return $self->caller->do_call($self, $call_object);
35             }
36             sub CreateClusterParameterGroup {
37 1     1 1 487 my $self = shift;
38 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateClusterParameterGroup', @_);
39 1         1069 return $self->caller->do_call($self, $call_object);
40             }
41             sub CreateClusterSecurityGroup {
42 1     1 1 470 my $self = shift;
43 1         9 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateClusterSecurityGroup', @_);
44 1         887 return $self->caller->do_call($self, $call_object);
45             }
46             sub CreateClusterSnapshot {
47 1     1 1 427 my $self = shift;
48 1         9 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateClusterSnapshot', @_);
49 1         878 return $self->caller->do_call($self, $call_object);
50             }
51             sub CreateClusterSubnetGroup {
52 1     1 1 575 my $self = shift;
53 1         9 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateClusterSubnetGroup', @_);
54 1         1303 return $self->caller->do_call($self, $call_object);
55             }
56             sub CreateEventSubscription {
57 0     0 1 0 my $self = shift;
58 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateEventSubscription', @_);
59 0         0 return $self->caller->do_call($self, $call_object);
60             }
61             sub CreateHsmClientCertificate {
62 0     0 1 0 my $self = shift;
63 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateHsmClientCertificate', @_);
64 0         0 return $self->caller->do_call($self, $call_object);
65             }
66             sub CreateHsmConfiguration {
67 0     0 1 0 my $self = shift;
68 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateHsmConfiguration', @_);
69 0         0 return $self->caller->do_call($self, $call_object);
70             }
71             sub CreateSnapshotCopyGrant {
72 0     0 1 0 my $self = shift;
73 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateSnapshotCopyGrant', @_);
74 0         0 return $self->caller->do_call($self, $call_object);
75             }
76             sub CreateTags {
77 0     0 1 0 my $self = shift;
78 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::CreateTags', @_);
79 0         0 return $self->caller->do_call($self, $call_object);
80             }
81             sub DeleteCluster {
82 1     1 1 420 my $self = shift;
83 1         9 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteCluster', @_);
84 1         1040 return $self->caller->do_call($self, $call_object);
85             }
86             sub DeleteClusterParameterGroup {
87 1     1 1 268 my $self = shift;
88 1         7 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteClusterParameterGroup', @_);
89 1         455 return $self->caller->do_call($self, $call_object);
90             }
91             sub DeleteClusterSecurityGroup {
92 0     0 1 0 my $self = shift;
93 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteClusterSecurityGroup', @_);
94 0         0 return $self->caller->do_call($self, $call_object);
95             }
96             sub DeleteClusterSnapshot {
97 1     1 1 337 my $self = shift;
98 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteClusterSnapshot', @_);
99 1         603 return $self->caller->do_call($self, $call_object);
100             }
101             sub DeleteClusterSubnetGroup {
102 0     0 1 0 my $self = shift;
103 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteClusterSubnetGroup', @_);
104 0         0 return $self->caller->do_call($self, $call_object);
105             }
106             sub DeleteEventSubscription {
107 0     0 1 0 my $self = shift;
108 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteEventSubscription', @_);
109 0         0 return $self->caller->do_call($self, $call_object);
110             }
111             sub DeleteHsmClientCertificate {
112 0     0 1 0 my $self = shift;
113 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteHsmClientCertificate', @_);
114 0         0 return $self->caller->do_call($self, $call_object);
115             }
116             sub DeleteHsmConfiguration {
117 0     0 1 0 my $self = shift;
118 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteHsmConfiguration', @_);
119 0         0 return $self->caller->do_call($self, $call_object);
120             }
121             sub DeleteSnapshotCopyGrant {
122 0     0 1 0 my $self = shift;
123 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteSnapshotCopyGrant', @_);
124 0         0 return $self->caller->do_call($self, $call_object);
125             }
126             sub DeleteTags {
127 0     0 1 0 my $self = shift;
128 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DeleteTags', @_);
129 0         0 return $self->caller->do_call($self, $call_object);
130             }
131             sub DescribeClusterParameterGroups {
132 1     1 1 304 my $self = shift;
133 1         9 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeClusterParameterGroups', @_);
134 1         819 return $self->caller->do_call($self, $call_object);
135             }
136             sub DescribeClusterParameters {
137 1     1 1 408 my $self = shift;
138 1         7 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeClusterParameters', @_);
139 1         771 return $self->caller->do_call($self, $call_object);
140             }
141             sub DescribeClusters {
142 1     1 1 307 my $self = shift;
143 1         6 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeClusters', @_);
144 1         693 return $self->caller->do_call($self, $call_object);
145             }
146             sub DescribeClusterSecurityGroups {
147 1     1 1 313 my $self = shift;
148 1         7 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeClusterSecurityGroups', @_);
149 1         712 return $self->caller->do_call($self, $call_object);
150             }
151             sub DescribeClusterSnapshots {
152 1     1 1 465 my $self = shift;
153 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeClusterSnapshots', @_);
154 1         1259 return $self->caller->do_call($self, $call_object);
155             }
156             sub DescribeClusterSubnetGroups {
157 1     1 1 318 my $self = shift;
158 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeClusterSubnetGroups', @_);
159 1         1005 return $self->caller->do_call($self, $call_object);
160             }
161             sub DescribeClusterVersions {
162 1     1 1 367 my $self = shift;
163 1         7 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeClusterVersions', @_);
164 1         599 return $self->caller->do_call($self, $call_object);
165             }
166             sub DescribeDefaultClusterParameters {
167 0     0 1 0 my $self = shift;
168 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeDefaultClusterParameters', @_);
169 0         0 return $self->caller->do_call($self, $call_object);
170             }
171             sub DescribeEventCategories {
172 0     0 1 0 my $self = shift;
173 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeEventCategories', @_);
174 0         0 return $self->caller->do_call($self, $call_object);
175             }
176             sub DescribeEvents {
177 1     1 1 365 my $self = shift;
178 1         6 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeEvents', @_);
179 1         981 return $self->caller->do_call($self, $call_object);
180             }
181             sub DescribeEventSubscriptions {
182 0     0 1 0 my $self = shift;
183 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeEventSubscriptions', @_);
184 0         0 return $self->caller->do_call($self, $call_object);
185             }
186             sub DescribeHsmClientCertificates {
187 0     0 1 0 my $self = shift;
188 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeHsmClientCertificates', @_);
189 0         0 return $self->caller->do_call($self, $call_object);
190             }
191             sub DescribeHsmConfigurations {
192 0     0 1 0 my $self = shift;
193 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeHsmConfigurations', @_);
194 0         0 return $self->caller->do_call($self, $call_object);
195             }
196             sub DescribeLoggingStatus {
197 0     0 1 0 my $self = shift;
198 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeLoggingStatus', @_);
199 0         0 return $self->caller->do_call($self, $call_object);
200             }
201             sub DescribeOrderableClusterOptions {
202 1     1 1 295 my $self = shift;
203 1         7 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeOrderableClusterOptions', @_);
204 1         722 return $self->caller->do_call($self, $call_object);
205             }
206             sub DescribeReservedNodeOfferings {
207 1     1 1 274 my $self = shift;
208 1         10 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeReservedNodeOfferings', @_);
209 1         508 return $self->caller->do_call($self, $call_object);
210             }
211             sub DescribeReservedNodes {
212 1     1 1 276 my $self = shift;
213 1         12 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeReservedNodes', @_);
214 1         536 return $self->caller->do_call($self, $call_object);
215             }
216             sub DescribeResize {
217 1     1 1 284 my $self = shift;
218 1         7 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeResize', @_);
219 1         480 return $self->caller->do_call($self, $call_object);
220             }
221             sub DescribeSnapshotCopyGrants {
222 0     0 1 0 my $self = shift;
223 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeSnapshotCopyGrants', @_);
224 0         0 return $self->caller->do_call($self, $call_object);
225             }
226             sub DescribeTableRestoreStatus {
227 0     0 1 0 my $self = shift;
228 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeTableRestoreStatus', @_);
229 0         0 return $self->caller->do_call($self, $call_object);
230             }
231             sub DescribeTags {
232 0     0 1 0 my $self = shift;
233 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DescribeTags', @_);
234 0         0 return $self->caller->do_call($self, $call_object);
235             }
236             sub DisableLogging {
237 0     0 1 0 my $self = shift;
238 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DisableLogging', @_);
239 0         0 return $self->caller->do_call($self, $call_object);
240             }
241             sub DisableSnapshotCopy {
242 0     0 1 0 my $self = shift;
243 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::DisableSnapshotCopy', @_);
244 0         0 return $self->caller->do_call($self, $call_object);
245             }
246             sub EnableLogging {
247 0     0 1 0 my $self = shift;
248 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::EnableLogging', @_);
249 0         0 return $self->caller->do_call($self, $call_object);
250             }
251             sub EnableSnapshotCopy {
252 0     0 1 0 my $self = shift;
253 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::EnableSnapshotCopy', @_);
254 0         0 return $self->caller->do_call($self, $call_object);
255             }
256             sub GetClusterCredentials {
257 0     0 1 0 my $self = shift;
258 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::GetClusterCredentials', @_);
259 0         0 return $self->caller->do_call($self, $call_object);
260             }
261             sub ModifyCluster {
262 0     0 1 0 my $self = shift;
263 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::ModifyCluster', @_);
264 0         0 return $self->caller->do_call($self, $call_object);
265             }
266             sub ModifyClusterIamRoles {
267 0     0 1 0 my $self = shift;
268 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::ModifyClusterIamRoles', @_);
269 0         0 return $self->caller->do_call($self, $call_object);
270             }
271             sub ModifyClusterParameterGroup {
272 1     1 1 580 my $self = shift;
273 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::ModifyClusterParameterGroup', @_);
274 1         780 return $self->caller->do_call($self, $call_object);
275             }
276             sub ModifyClusterSubnetGroup {
277 0     0 1 0 my $self = shift;
278 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::ModifyClusterSubnetGroup', @_);
279 0         0 return $self->caller->do_call($self, $call_object);
280             }
281             sub ModifyEventSubscription {
282 0     0 1 0 my $self = shift;
283 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::ModifyEventSubscription', @_);
284 0         0 return $self->caller->do_call($self, $call_object);
285             }
286             sub ModifySnapshotCopyRetentionPeriod {
287 0     0 1 0 my $self = shift;
288 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::ModifySnapshotCopyRetentionPeriod', @_);
289 0         0 return $self->caller->do_call($self, $call_object);
290             }
291             sub PurchaseReservedNodeOffering {
292 1     1 1 334 my $self = shift;
293 1         7 my $call_object = $self->new_with_coercions('Paws::RedShift::PurchaseReservedNodeOffering', @_);
294 1         664 return $self->caller->do_call($self, $call_object);
295             }
296             sub RebootCluster {
297 1     1 1 279 my $self = shift;
298 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::RebootCluster', @_);
299 1         546 return $self->caller->do_call($self, $call_object);
300             }
301             sub ResetClusterParameterGroup {
302 1     1 1 428 my $self = shift;
303 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::ResetClusterParameterGroup', @_);
304 1         705 return $self->caller->do_call($self, $call_object);
305             }
306             sub RestoreFromClusterSnapshot {
307 1     1 1 980 my $self = shift;
308 1         8 my $call_object = $self->new_with_coercions('Paws::RedShift::RestoreFromClusterSnapshot', @_);
309 1         3056 return $self->caller->do_call($self, $call_object);
310             }
311             sub RestoreTableFromClusterSnapshot {
312 0     0 1 0 my $self = shift;
313 0         0 my $call_object = $self->new_with_coercions('Paws::RedShift::RestoreTableFromClusterSnapshot', @_);
314 0         0 return $self->caller->do_call($self, $call_object);
315             }
316             sub RevokeClusterSecurityGroupIngress {
317 1     1 1 401 my $self = shift;
318 1         10 my $call_object = $self->new_with_coercions('Paws::RedShift::RevokeClusterSecurityGroupIngress', @_);
319 1         906 return $self->caller->do_call($self, $call_object);
320             }
321             sub RevokeSnapshotAccess {
322 0     0 1   my $self = shift;
323 0           my $call_object = $self->new_with_coercions('Paws::RedShift::RevokeSnapshotAccess', @_);
324 0           return $self->caller->do_call($self, $call_object);
325             }
326             sub RotateEncryptionKey {
327 0     0 1   my $self = shift;
328 0           my $call_object = $self->new_with_coercions('Paws::RedShift::RotateEncryptionKey', @_);
329 0           return $self->caller->do_call($self, $call_object);
330             }
331            
332             sub DescribeAllClusterParameterGroups {
333 0     0 1   my $self = shift;
334              
335 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
336 0           my $result = $self->DescribeClusterParameterGroups(@_);
337 0           my $next_result = $result;
338              
339 0 0         if (not defined $callback) {
340 0           while ($next_result->Marker) {
341 0           $next_result = $self->DescribeClusterParameterGroups(@_, Marker => $next_result->Marker);
342 0           push @{ $result->ParameterGroups }, @{ $next_result->ParameterGroups };
  0            
  0            
343             }
344 0           return $result;
345             } else {
346 0           while ($result->Marker) {
347 0           $callback->($_ => 'ParameterGroups') foreach (@{ $result->ParameterGroups });
  0            
348 0           $result = $self->DescribeClusterParameterGroups(@_, Marker => $result->Marker);
349             }
350 0           $callback->($_ => 'ParameterGroups') foreach (@{ $result->ParameterGroups });
  0            
351             }
352              
353             return undef
354 0           }
355             sub DescribeAllClusterParameters {
356 0     0 1   my $self = shift;
357              
358 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
359 0           my $result = $self->DescribeClusterParameters(@_);
360 0           my $next_result = $result;
361              
362 0 0         if (not defined $callback) {
363 0           while ($next_result->Marker) {
364 0           $next_result = $self->DescribeClusterParameters(@_, Marker => $next_result->Marker);
365 0           push @{ $result->Parameters }, @{ $next_result->Parameters };
  0            
  0            
366             }
367 0           return $result;
368             } else {
369 0           while ($result->Marker) {
370 0           $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
  0            
371 0           $result = $self->DescribeClusterParameters(@_, Marker => $result->Marker);
372             }
373 0           $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
  0            
374             }
375              
376             return undef
377 0           }
378             sub DescribeAllClusters {
379 0     0 1   my $self = shift;
380              
381 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
382 0           my $result = $self->DescribeClusters(@_);
383 0           my $next_result = $result;
384              
385 0 0         if (not defined $callback) {
386 0           while ($next_result->Marker) {
387 0           $next_result = $self->DescribeClusters(@_, Marker => $next_result->Marker);
388 0           push @{ $result->Clusters }, @{ $next_result->Clusters };
  0            
  0            
389             }
390 0           return $result;
391             } else {
392 0           while ($result->Marker) {
393 0           $callback->($_ => 'Clusters') foreach (@{ $result->Clusters });
  0            
394 0           $result = $self->DescribeClusters(@_, Marker => $result->Marker);
395             }
396 0           $callback->($_ => 'Clusters') foreach (@{ $result->Clusters });
  0            
397             }
398              
399             return undef
400 0           }
401             sub DescribeAllClusterSecurityGroups {
402 0     0 1   my $self = shift;
403              
404 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
405 0           my $result = $self->DescribeClusterSecurityGroups(@_);
406 0           my $next_result = $result;
407              
408 0 0         if (not defined $callback) {
409 0           while ($next_result->Marker) {
410 0           $next_result = $self->DescribeClusterSecurityGroups(@_, Marker => $next_result->Marker);
411 0           push @{ $result->ClusterSecurityGroups }, @{ $next_result->ClusterSecurityGroups };
  0            
  0            
412             }
413 0           return $result;
414             } else {
415 0           while ($result->Marker) {
416 0           $callback->($_ => 'ClusterSecurityGroups') foreach (@{ $result->ClusterSecurityGroups });
  0            
417 0           $result = $self->DescribeClusterSecurityGroups(@_, Marker => $result->Marker);
418             }
419 0           $callback->($_ => 'ClusterSecurityGroups') foreach (@{ $result->ClusterSecurityGroups });
  0            
420             }
421              
422             return undef
423 0           }
424             sub DescribeAllClusterSnapshots {
425 0     0 1   my $self = shift;
426              
427 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
428 0           my $result = $self->DescribeClusterSnapshots(@_);
429 0           my $next_result = $result;
430              
431 0 0         if (not defined $callback) {
432 0           while ($next_result->Marker) {
433 0           $next_result = $self->DescribeClusterSnapshots(@_, Marker => $next_result->Marker);
434 0           push @{ $result->Snapshots }, @{ $next_result->Snapshots };
  0            
  0            
435             }
436 0           return $result;
437             } else {
438 0           while ($result->Marker) {
439 0           $callback->($_ => 'Snapshots') foreach (@{ $result->Snapshots });
  0            
440 0           $result = $self->DescribeClusterSnapshots(@_, Marker => $result->Marker);
441             }
442 0           $callback->($_ => 'Snapshots') foreach (@{ $result->Snapshots });
  0            
443             }
444              
445             return undef
446 0           }
447             sub DescribeAllClusterSubnetGroups {
448 0     0 1   my $self = shift;
449              
450 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
451 0           my $result = $self->DescribeClusterSubnetGroups(@_);
452 0           my $next_result = $result;
453              
454 0 0         if (not defined $callback) {
455 0           while ($next_result->Marker) {
456 0           $next_result = $self->DescribeClusterSubnetGroups(@_, Marker => $next_result->Marker);
457 0           push @{ $result->ClusterSubnetGroups }, @{ $next_result->ClusterSubnetGroups };
  0            
  0            
458             }
459 0           return $result;
460             } else {
461 0           while ($result->Marker) {
462 0           $callback->($_ => 'ClusterSubnetGroups') foreach (@{ $result->ClusterSubnetGroups });
  0            
463 0           $result = $self->DescribeClusterSubnetGroups(@_, Marker => $result->Marker);
464             }
465 0           $callback->($_ => 'ClusterSubnetGroups') foreach (@{ $result->ClusterSubnetGroups });
  0            
466             }
467              
468             return undef
469 0           }
470             sub DescribeAllClusterVersions {
471 0     0 1   my $self = shift;
472              
473 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
474 0           my $result = $self->DescribeClusterVersions(@_);
475 0           my $next_result = $result;
476              
477 0 0         if (not defined $callback) {
478 0           while ($next_result->Marker) {
479 0           $next_result = $self->DescribeClusterVersions(@_, Marker => $next_result->Marker);
480 0           push @{ $result->ClusterVersions }, @{ $next_result->ClusterVersions };
  0            
  0            
481             }
482 0           return $result;
483             } else {
484 0           while ($result->Marker) {
485 0           $callback->($_ => 'ClusterVersions') foreach (@{ $result->ClusterVersions });
  0            
486 0           $result = $self->DescribeClusterVersions(@_, Marker => $result->Marker);
487             }
488 0           $callback->($_ => 'ClusterVersions') foreach (@{ $result->ClusterVersions });
  0            
489             }
490              
491             return undef
492 0           }
493             sub DescribeAllDefaultClusterParameters {
494 0     0 1   my $self = shift;
495              
496 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
497 0           my $result = $self->DescribeDefaultClusterParameters(@_);
498 0           my $next_result = $result;
499              
500 0 0         if (not defined $callback) {
501 0           while ($next_result->DefaultClusterParameters->Marker) {
502 0           $next_result = $self->DescribeDefaultClusterParameters(@_, Marker => $next_result->DefaultClusterParameters->Marker);
503 0           push @{ $result->DefaultClusterParameters->Parameters }, @{ $next_result->DefaultClusterParameters->Parameters };
  0            
  0            
504             }
505 0           return $result;
506             } else {
507 0           while ($result->DefaultClusterParameters->Marker) {
508 0           $callback->($_ => 'DefaultClusterParameters.Parameters') foreach (@{ $result->DefaultClusterParameters->Parameters });
  0            
509 0           $result = $self->DescribeDefaultClusterParameters(@_, Marker => $result->DefaultClusterParameters->Marker);
510             }
511 0           $callback->($_ => 'DefaultClusterParameters.Parameters') foreach (@{ $result->DefaultClusterParameters->Parameters });
  0            
512             }
513              
514             return undef
515 0           }
516             sub DescribeAllEvents {
517 0     0 1   my $self = shift;
518              
519 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
520 0           my $result = $self->DescribeEvents(@_);
521 0           my $next_result = $result;
522              
523 0 0         if (not defined $callback) {
524 0           while ($next_result->Marker) {
525 0           $next_result = $self->DescribeEvents(@_, Marker => $next_result->Marker);
526 0           push @{ $result->Events }, @{ $next_result->Events };
  0            
  0            
527             }
528 0           return $result;
529             } else {
530 0           while ($result->Marker) {
531 0           $callback->($_ => 'Events') foreach (@{ $result->Events });
  0            
532 0           $result = $self->DescribeEvents(@_, Marker => $result->Marker);
533             }
534 0           $callback->($_ => 'Events') foreach (@{ $result->Events });
  0            
535             }
536              
537             return undef
538 0           }
539             sub DescribeAllEventSubscriptions {
540 0     0 1   my $self = shift;
541              
542 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
543 0           my $result = $self->DescribeEventSubscriptions(@_);
544 0           my $next_result = $result;
545              
546 0 0         if (not defined $callback) {
547 0           while ($next_result->Marker) {
548 0           $next_result = $self->DescribeEventSubscriptions(@_, Marker => $next_result->Marker);
549 0           push @{ $result->EventSubscriptionsList }, @{ $next_result->EventSubscriptionsList };
  0            
  0            
550             }
551 0           return $result;
552             } else {
553 0           while ($result->Marker) {
554 0           $callback->($_ => 'EventSubscriptionsList') foreach (@{ $result->EventSubscriptionsList });
  0            
555 0           $result = $self->DescribeEventSubscriptions(@_, Marker => $result->Marker);
556             }
557 0           $callback->($_ => 'EventSubscriptionsList') foreach (@{ $result->EventSubscriptionsList });
  0            
558             }
559              
560             return undef
561 0           }
562             sub DescribeAllHsmClientCertificates {
563 0     0 1   my $self = shift;
564              
565 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
566 0           my $result = $self->DescribeHsmClientCertificates(@_);
567 0           my $next_result = $result;
568              
569 0 0         if (not defined $callback) {
570 0           while ($next_result->Marker) {
571 0           $next_result = $self->DescribeHsmClientCertificates(@_, Marker => $next_result->Marker);
572 0           push @{ $result->HsmClientCertificates }, @{ $next_result->HsmClientCertificates };
  0            
  0            
573             }
574 0           return $result;
575             } else {
576 0           while ($result->Marker) {
577 0           $callback->($_ => 'HsmClientCertificates') foreach (@{ $result->HsmClientCertificates });
  0            
578 0           $result = $self->DescribeHsmClientCertificates(@_, Marker => $result->Marker);
579             }
580 0           $callback->($_ => 'HsmClientCertificates') foreach (@{ $result->HsmClientCertificates });
  0            
581             }
582              
583             return undef
584 0           }
585             sub DescribeAllHsmConfigurations {
586 0     0 1   my $self = shift;
587              
588 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
589 0           my $result = $self->DescribeHsmConfigurations(@_);
590 0           my $next_result = $result;
591              
592 0 0         if (not defined $callback) {
593 0           while ($next_result->Marker) {
594 0           $next_result = $self->DescribeHsmConfigurations(@_, Marker => $next_result->Marker);
595 0           push @{ $result->HsmConfigurations }, @{ $next_result->HsmConfigurations };
  0            
  0            
596             }
597 0           return $result;
598             } else {
599 0           while ($result->Marker) {
600 0           $callback->($_ => 'HsmConfigurations') foreach (@{ $result->HsmConfigurations });
  0            
601 0           $result = $self->DescribeHsmConfigurations(@_, Marker => $result->Marker);
602             }
603 0           $callback->($_ => 'HsmConfigurations') foreach (@{ $result->HsmConfigurations });
  0            
604             }
605              
606             return undef
607 0           }
608             sub DescribeAllOrderableClusterOptions {
609 0     0 1   my $self = shift;
610              
611 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
612 0           my $result = $self->DescribeOrderableClusterOptions(@_);
613 0           my $next_result = $result;
614              
615 0 0         if (not defined $callback) {
616 0           while ($next_result->Marker) {
617 0           $next_result = $self->DescribeOrderableClusterOptions(@_, Marker => $next_result->Marker);
618 0           push @{ $result->OrderableClusterOptions }, @{ $next_result->OrderableClusterOptions };
  0            
  0            
619             }
620 0           return $result;
621             } else {
622 0           while ($result->Marker) {
623 0           $callback->($_ => 'OrderableClusterOptions') foreach (@{ $result->OrderableClusterOptions });
  0            
624 0           $result = $self->DescribeOrderableClusterOptions(@_, Marker => $result->Marker);
625             }
626 0           $callback->($_ => 'OrderableClusterOptions') foreach (@{ $result->OrderableClusterOptions });
  0            
627             }
628              
629             return undef
630 0           }
631             sub DescribeAllReservedNodeOfferings {
632 0     0 1   my $self = shift;
633              
634 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
635 0           my $result = $self->DescribeReservedNodeOfferings(@_);
636 0           my $next_result = $result;
637              
638 0 0         if (not defined $callback) {
639 0           while ($next_result->Marker) {
640 0           $next_result = $self->DescribeReservedNodeOfferings(@_, Marker => $next_result->Marker);
641 0           push @{ $result->ReservedNodeOfferings }, @{ $next_result->ReservedNodeOfferings };
  0            
  0            
642             }
643 0           return $result;
644             } else {
645 0           while ($result->Marker) {
646 0           $callback->($_ => 'ReservedNodeOfferings') foreach (@{ $result->ReservedNodeOfferings });
  0            
647 0           $result = $self->DescribeReservedNodeOfferings(@_, Marker => $result->Marker);
648             }
649 0           $callback->($_ => 'ReservedNodeOfferings') foreach (@{ $result->ReservedNodeOfferings });
  0            
650             }
651              
652             return undef
653 0           }
654             sub DescribeAllReservedNodes {
655 0     0 1   my $self = shift;
656              
657 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
658 0           my $result = $self->DescribeReservedNodes(@_);
659 0           my $next_result = $result;
660              
661 0 0         if (not defined $callback) {
662 0           while ($next_result->Marker) {
663 0           $next_result = $self->DescribeReservedNodes(@_, Marker => $next_result->Marker);
664 0           push @{ $result->ReservedNodes }, @{ $next_result->ReservedNodes };
  0            
  0            
665             }
666 0           return $result;
667             } else {
668 0           while ($result->Marker) {
669 0           $callback->($_ => 'ReservedNodes') foreach (@{ $result->ReservedNodes });
  0            
670 0           $result = $self->DescribeReservedNodes(@_, Marker => $result->Marker);
671             }
672 0           $callback->($_ => 'ReservedNodes') foreach (@{ $result->ReservedNodes });
  0            
673             }
674              
675             return undef
676 0           }
677              
678              
679 0     0 0   sub operations { qw/AuthorizeClusterSecurityGroupIngress AuthorizeSnapshotAccess CopyClusterSnapshot CreateCluster CreateClusterParameterGroup CreateClusterSecurityGroup CreateClusterSnapshot CreateClusterSubnetGroup CreateEventSubscription CreateHsmClientCertificate CreateHsmConfiguration CreateSnapshotCopyGrant CreateTags DeleteCluster DeleteClusterParameterGroup DeleteClusterSecurityGroup DeleteClusterSnapshot DeleteClusterSubnetGroup DeleteEventSubscription DeleteHsmClientCertificate DeleteHsmConfiguration DeleteSnapshotCopyGrant DeleteTags DescribeClusterParameterGroups DescribeClusterParameters DescribeClusters DescribeClusterSecurityGroups DescribeClusterSnapshots DescribeClusterSubnetGroups DescribeClusterVersions DescribeDefaultClusterParameters DescribeEventCategories DescribeEvents DescribeEventSubscriptions DescribeHsmClientCertificates DescribeHsmConfigurations DescribeLoggingStatus DescribeOrderableClusterOptions DescribeReservedNodeOfferings DescribeReservedNodes DescribeResize DescribeSnapshotCopyGrants DescribeTableRestoreStatus DescribeTags DisableLogging DisableSnapshotCopy EnableLogging EnableSnapshotCopy GetClusterCredentials ModifyCluster ModifyClusterIamRoles ModifyClusterParameterGroup ModifyClusterSubnetGroup ModifyEventSubscription ModifySnapshotCopyRetentionPeriod PurchaseReservedNodeOffering RebootCluster ResetClusterParameterGroup RestoreFromClusterSnapshot RestoreTableFromClusterSnapshot RevokeClusterSecurityGroupIngress RevokeSnapshotAccess RotateEncryptionKey / }
680              
681             1;
682              
683             ### main pod documentation begin ###
684              
685             =head1 NAME
686              
687             Paws::RedShift - Perl Interface to AWS Amazon Redshift
688              
689             =head1 SYNOPSIS
690              
691             use Paws;
692              
693             my $obj = Paws->service('RedShift');
694             my $res = $obj->Method(
695             Arg1 => $val1,
696             Arg2 => [ 'V1', 'V2' ],
697             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
698             # of the arguments type
699             Arg3 => { Att1 => 'Val1' },
700             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
701             # the constructor of the arguments type
702             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
703             );
704              
705             =head1 DESCRIPTION
706              
707             Amazon Redshift
708              
709             B<Overview>
710              
711             This is an interface reference for Amazon Redshift. It contains
712             documentation for one of the programming or command line interfaces you
713             can use to manage Amazon Redshift clusters. Note that Amazon Redshift
714             is asynchronous, which means that some interfaces may require
715             techniques, such as polling or asynchronous callback handlers, to
716             determine when a command has been applied. In this reference, the
717             parameter descriptions indicate whether a change is applied
718             immediately, on the next instance reboot, or during the next
719             maintenance window. For a summary of the Amazon Redshift cluster
720             management interfaces, go to Using the Amazon Redshift Management
721             Interfaces.
722              
723             Amazon Redshift manages all the work of setting up, operating, and
724             scaling a data warehouse: provisioning capacity, monitoring and backing
725             up the cluster, and applying patches and upgrades to the Amazon
726             Redshift engine. You can focus on using your data to acquire new
727             insights for your business and customers.
728              
729             If you are a first-time user of Amazon Redshift, we recommend that you
730             begin by reading the Amazon Redshift Getting Started Guide.
731              
732             If you are a database developer, the Amazon Redshift Database Developer
733             Guide explains how to design, build, query, and maintain the databases
734             that make up your data warehouse.
735              
736             =head1 METHODS
737              
738             =head2 AuthorizeClusterSecurityGroupIngress(ClusterSecurityGroupName => Str, [CIDRIP => Str, EC2SecurityGroupName => Str, EC2SecurityGroupOwnerId => Str])
739              
740             Each argument is described in detail in: L<Paws::RedShift::AuthorizeClusterSecurityGroupIngress>
741              
742             Returns: a L<Paws::RedShift::AuthorizeClusterSecurityGroupIngressResult> instance
743              
744             Adds an inbound (ingress) rule to an Amazon Redshift security group.
745             Depending on whether the application accessing your cluster is running
746             on the Internet or an Amazon EC2 instance, you can authorize inbound
747             access to either a Classless Interdomain Routing (CIDR)/Internet
748             Protocol (IP) range or to an Amazon EC2 security group. You can add as
749             many as 20 ingress rules to an Amazon Redshift security group.
750              
751             If you authorize access to an Amazon EC2 security group, specify
752             I<EC2SecurityGroupName> and I<EC2SecurityGroupOwnerId>. The Amazon EC2
753             security group and Amazon Redshift cluster must be in the same AWS
754             region.
755              
756             If you authorize access to a CIDR/IP address range, specify I<CIDRIP>.
757             For an overview of CIDR blocks, see the Wikipedia article on Classless
758             Inter-Domain Routing.
759              
760             You must also associate the security group with a cluster so that
761             clients running on these IP addresses or the EC2 instance are
762             authorized to connect to the cluster. For information about managing
763             security groups, go to Working with Security Groups in the I<Amazon
764             Redshift Cluster Management Guide>.
765              
766              
767             =head2 AuthorizeSnapshotAccess(AccountWithRestoreAccess => Str, SnapshotIdentifier => Str, [SnapshotClusterIdentifier => Str])
768              
769             Each argument is described in detail in: L<Paws::RedShift::AuthorizeSnapshotAccess>
770              
771             Returns: a L<Paws::RedShift::AuthorizeSnapshotAccessResult> instance
772              
773             Authorizes the specified AWS customer account to restore the specified
774             snapshot.
775              
776             For more information about working with snapshots, go to Amazon
777             Redshift Snapshots in the I<Amazon Redshift Cluster Management Guide>.
778              
779              
780             =head2 CopyClusterSnapshot(SourceSnapshotIdentifier => Str, TargetSnapshotIdentifier => Str, [SourceSnapshotClusterIdentifier => Str])
781              
782             Each argument is described in detail in: L<Paws::RedShift::CopyClusterSnapshot>
783              
784             Returns: a L<Paws::RedShift::CopyClusterSnapshotResult> instance
785              
786             Copies the specified automated cluster snapshot to a new manual cluster
787             snapshot. The source must be an automated snapshot and it must be in
788             the available state.
789              
790             When you delete a cluster, Amazon Redshift deletes any automated
791             snapshots of the cluster. Also, when the retention period of the
792             snapshot expires, Amazon Redshift automatically deletes it. If you want
793             to keep an automated snapshot for a longer period, you can make a
794             manual copy of the snapshot. Manual snapshots are retained until you
795             delete them.
796              
797             For more information about working with snapshots, go to Amazon
798             Redshift Snapshots in the I<Amazon Redshift Cluster Management Guide>.
799              
800              
801             =head2 CreateCluster(ClusterIdentifier => Str, MasterUsername => Str, MasterUserPassword => Str, NodeType => Str, [AdditionalInfo => Str, AllowVersionUpgrade => Bool, AutomatedSnapshotRetentionPeriod => Int, AvailabilityZone => Str, ClusterParameterGroupName => Str, ClusterSecurityGroups => ArrayRef[Str|Undef], ClusterSubnetGroupName => Str, ClusterType => Str, ClusterVersion => Str, DBName => Str, ElasticIp => Str, Encrypted => Bool, EnhancedVpcRouting => Bool, HsmClientCertificateIdentifier => Str, HsmConfigurationIdentifier => Str, IamRoles => ArrayRef[Str|Undef], KmsKeyId => Str, NumberOfNodes => Int, Port => Int, PreferredMaintenanceWindow => Str, PubliclyAccessible => Bool, Tags => ArrayRef[L<Paws::RedShift::Tag>], VpcSecurityGroupIds => ArrayRef[Str|Undef]])
802              
803             Each argument is described in detail in: L<Paws::RedShift::CreateCluster>
804              
805             Returns: a L<Paws::RedShift::CreateClusterResult> instance
806              
807             Creates a new cluster.
808              
809             To create the cluster in Virtual Private Cloud (VPC), you must provide
810             a cluster subnet group name. The cluster subnet group identifies the
811             subnets of your VPC that Amazon Redshift uses when creating the
812             cluster. For more information about managing clusters, go to Amazon
813             Redshift Clusters in the I<Amazon Redshift Cluster Management Guide>.
814              
815              
816             =head2 CreateClusterParameterGroup(Description => Str, ParameterGroupFamily => Str, ParameterGroupName => Str, [Tags => ArrayRef[L<Paws::RedShift::Tag>]])
817              
818             Each argument is described in detail in: L<Paws::RedShift::CreateClusterParameterGroup>
819              
820             Returns: a L<Paws::RedShift::CreateClusterParameterGroupResult> instance
821              
822             Creates an Amazon Redshift parameter group.
823              
824             Creating parameter groups is independent of creating clusters. You can
825             associate a cluster with a parameter group when you create the cluster.
826             You can also associate an existing cluster with a parameter group after
827             the cluster is created by using ModifyCluster.
828              
829             Parameters in the parameter group define specific behavior that applies
830             to the databases you create on the cluster. For more information about
831             parameters and parameter groups, go to Amazon Redshift Parameter Groups
832             in the I<Amazon Redshift Cluster Management Guide>.
833              
834              
835             =head2 CreateClusterSecurityGroup(ClusterSecurityGroupName => Str, Description => Str, [Tags => ArrayRef[L<Paws::RedShift::Tag>]])
836              
837             Each argument is described in detail in: L<Paws::RedShift::CreateClusterSecurityGroup>
838              
839             Returns: a L<Paws::RedShift::CreateClusterSecurityGroupResult> instance
840              
841             Creates a new Amazon Redshift security group. You use security groups
842             to control access to non-VPC clusters.
843              
844             For information about managing security groups, go to Amazon Redshift
845             Cluster Security Groups in the I<Amazon Redshift Cluster Management
846             Guide>.
847              
848              
849             =head2 CreateClusterSnapshot(ClusterIdentifier => Str, SnapshotIdentifier => Str, [Tags => ArrayRef[L<Paws::RedShift::Tag>]])
850              
851             Each argument is described in detail in: L<Paws::RedShift::CreateClusterSnapshot>
852              
853             Returns: a L<Paws::RedShift::CreateClusterSnapshotResult> instance
854              
855             Creates a manual snapshot of the specified cluster. The cluster must be
856             in the C<available> state.
857              
858             For more information about working with snapshots, go to Amazon
859             Redshift Snapshots in the I<Amazon Redshift Cluster Management Guide>.
860              
861              
862             =head2 CreateClusterSubnetGroup(ClusterSubnetGroupName => Str, Description => Str, SubnetIds => ArrayRef[Str|Undef], [Tags => ArrayRef[L<Paws::RedShift::Tag>]])
863              
864             Each argument is described in detail in: L<Paws::RedShift::CreateClusterSubnetGroup>
865              
866             Returns: a L<Paws::RedShift::CreateClusterSubnetGroupResult> instance
867              
868             Creates a new Amazon Redshift subnet group. You must provide a list of
869             one or more subnets in your existing Amazon Virtual Private Cloud
870             (Amazon VPC) when creating Amazon Redshift subnet group.
871              
872             For information about subnet groups, go to Amazon Redshift Cluster
873             Subnet Groups in the I<Amazon Redshift Cluster Management Guide>.
874              
875              
876             =head2 CreateEventSubscription(SnsTopicArn => Str, SubscriptionName => Str, [Enabled => Bool, EventCategories => ArrayRef[Str|Undef], Severity => Str, SourceIds => ArrayRef[Str|Undef], SourceType => Str, Tags => ArrayRef[L<Paws::RedShift::Tag>]])
877              
878             Each argument is described in detail in: L<Paws::RedShift::CreateEventSubscription>
879              
880             Returns: a L<Paws::RedShift::CreateEventSubscriptionResult> instance
881              
882             Creates an Amazon Redshift event notification subscription. This action
883             requires an ARN (Amazon Resource Name) of an Amazon SNS topic created
884             by either the Amazon Redshift console, the Amazon SNS console, or the
885             Amazon SNS API. To obtain an ARN with Amazon SNS, you must create a
886             topic in Amazon SNS and subscribe to the topic. The ARN is displayed in
887             the SNS console.
888              
889             You can specify the source type, and lists of Amazon Redshift source
890             IDs, event categories, and event severities. Notifications will be sent
891             for all events you want that match those criteria. For example, you can
892             specify source type = cluster, source ID = my-cluster-1 and mycluster2,
893             event categories = Availability, Backup, and severity = ERROR. The
894             subscription will only send notifications for those ERROR events in the
895             Availability and Backup categories for the specified clusters.
896              
897             If you specify both the source type and source IDs, such as source type
898             = cluster and source identifier = my-cluster-1, notifications will be
899             sent for all the cluster events for my-cluster-1. If you specify a
900             source type but do not specify a source identifier, you will receive
901             notice of the events for the objects of that type in your AWS account.
902             If you do not specify either the SourceType nor the SourceIdentifier,
903             you will be notified of events generated from all Amazon Redshift
904             sources belonging to your AWS account. You must specify a source type
905             if you specify a source ID.
906              
907              
908             =head2 CreateHsmClientCertificate(HsmClientCertificateIdentifier => Str, [Tags => ArrayRef[L<Paws::RedShift::Tag>]])
909              
910             Each argument is described in detail in: L<Paws::RedShift::CreateHsmClientCertificate>
911              
912             Returns: a L<Paws::RedShift::CreateHsmClientCertificateResult> instance
913              
914             Creates an HSM client certificate that an Amazon Redshift cluster will
915             use to connect to the client's HSM in order to store and retrieve the
916             keys used to encrypt the cluster databases.
917              
918             The command returns a public key, which you must store in the HSM. In
919             addition to creating the HSM certificate, you must create an Amazon
920             Redshift HSM configuration that provides a cluster the information
921             needed to store and use encryption keys in the HSM. For more
922             information, go to Hardware Security Modules in the Amazon Redshift
923             Cluster Management Guide.
924              
925              
926             =head2 CreateHsmConfiguration(Description => Str, HsmConfigurationIdentifier => Str, HsmIpAddress => Str, HsmPartitionName => Str, HsmPartitionPassword => Str, HsmServerPublicCertificate => Str, [Tags => ArrayRef[L<Paws::RedShift::Tag>]])
927              
928             Each argument is described in detail in: L<Paws::RedShift::CreateHsmConfiguration>
929              
930             Returns: a L<Paws::RedShift::CreateHsmConfigurationResult> instance
931              
932             Creates an HSM configuration that contains the information required by
933             an Amazon Redshift cluster to store and use database encryption keys in
934             a Hardware Security Module (HSM). After creating the HSM configuration,
935             you can specify it as a parameter when creating a cluster. The cluster
936             will then store its encryption keys in the HSM.
937              
938             In addition to creating an HSM configuration, you must also create an
939             HSM client certificate. For more information, go to Hardware Security
940             Modules in the Amazon Redshift Cluster Management Guide.
941              
942              
943             =head2 CreateSnapshotCopyGrant(SnapshotCopyGrantName => Str, [KmsKeyId => Str, Tags => ArrayRef[L<Paws::RedShift::Tag>]])
944              
945             Each argument is described in detail in: L<Paws::RedShift::CreateSnapshotCopyGrant>
946              
947             Returns: a L<Paws::RedShift::CreateSnapshotCopyGrantResult> instance
948              
949             Creates a snapshot copy grant that permits Amazon Redshift to use a
950             customer master key (CMK) from AWS Key Management Service (AWS KMS) to
951             encrypt copied snapshots in a destination region.
952              
953             For more information about managing snapshot copy grants, go to Amazon
954             Redshift Database Encryption in the I<Amazon Redshift Cluster
955             Management Guide>.
956              
957              
958             =head2 CreateTags(ResourceName => Str, Tags => ArrayRef[L<Paws::RedShift::Tag>])
959              
960             Each argument is described in detail in: L<Paws::RedShift::CreateTags>
961              
962             Returns: nothing
963              
964             Adds one or more tags to a specified resource.
965              
966             A resource can have up to 10 tags. If you try to create more than 10
967             tags for a resource, you will receive an error and the attempt will
968             fail.
969              
970             If you specify a key that already exists for the resource, the value
971             for that key will be updated with the new value.
972              
973              
974             =head2 DeleteCluster(ClusterIdentifier => Str, [FinalClusterSnapshotIdentifier => Str, SkipFinalClusterSnapshot => Bool])
975              
976             Each argument is described in detail in: L<Paws::RedShift::DeleteCluster>
977              
978             Returns: a L<Paws::RedShift::DeleteClusterResult> instance
979              
980             Deletes a previously provisioned cluster. A successful response from
981             the web service indicates that the request was received correctly. Use
982             DescribeClusters to monitor the status of the deletion. The delete
983             operation cannot be canceled or reverted once submitted. For more
984             information about managing clusters, go to Amazon Redshift Clusters in
985             the I<Amazon Redshift Cluster Management Guide>.
986              
987             If you want to shut down the cluster and retain it for future use, set
988             I<SkipFinalClusterSnapshot> to C<false> and specify a name for
989             I<FinalClusterSnapshotIdentifier>. You can later restore this snapshot
990             to resume using the cluster. If a final cluster snapshot is requested,
991             the status of the cluster will be "final-snapshot" while the snapshot
992             is being taken, then it's "deleting" once Amazon Redshift begins
993             deleting the cluster.
994              
995             For more information about managing clusters, go to Amazon Redshift
996             Clusters in the I<Amazon Redshift Cluster Management Guide>.
997              
998              
999             =head2 DeleteClusterParameterGroup(ParameterGroupName => Str)
1000              
1001             Each argument is described in detail in: L<Paws::RedShift::DeleteClusterParameterGroup>
1002              
1003             Returns: nothing
1004              
1005             Deletes a specified Amazon Redshift parameter group.
1006              
1007             You cannot delete a parameter group if it is associated with a cluster.
1008              
1009              
1010             =head2 DeleteClusterSecurityGroup(ClusterSecurityGroupName => Str)
1011              
1012             Each argument is described in detail in: L<Paws::RedShift::DeleteClusterSecurityGroup>
1013              
1014             Returns: nothing
1015              
1016             Deletes an Amazon Redshift security group.
1017              
1018             You cannot delete a security group that is associated with any
1019             clusters. You cannot delete the default security group.
1020              
1021             For information about managing security groups, go to Amazon Redshift
1022             Cluster Security Groups in the I<Amazon Redshift Cluster Management
1023             Guide>.
1024              
1025              
1026             =head2 DeleteClusterSnapshot(SnapshotIdentifier => Str, [SnapshotClusterIdentifier => Str])
1027              
1028             Each argument is described in detail in: L<Paws::RedShift::DeleteClusterSnapshot>
1029              
1030             Returns: a L<Paws::RedShift::DeleteClusterSnapshotResult> instance
1031              
1032             Deletes the specified manual snapshot. The snapshot must be in the
1033             C<available> state, with no other users authorized to access the
1034             snapshot.
1035              
1036             Unlike automated snapshots, manual snapshots are retained even after
1037             you delete your cluster. Amazon Redshift does not delete your manual
1038             snapshots. You must delete manual snapshot explicitly to avoid getting
1039             charged. If other accounts are authorized to access the snapshot, you
1040             must revoke all of the authorizations before you can delete the
1041             snapshot.
1042              
1043              
1044             =head2 DeleteClusterSubnetGroup(ClusterSubnetGroupName => Str)
1045              
1046             Each argument is described in detail in: L<Paws::RedShift::DeleteClusterSubnetGroup>
1047              
1048             Returns: nothing
1049              
1050             Deletes the specified cluster subnet group.
1051              
1052              
1053             =head2 DeleteEventSubscription(SubscriptionName => Str)
1054              
1055             Each argument is described in detail in: L<Paws::RedShift::DeleteEventSubscription>
1056              
1057             Returns: nothing
1058              
1059             Deletes an Amazon Redshift event notification subscription.
1060              
1061              
1062             =head2 DeleteHsmClientCertificate(HsmClientCertificateIdentifier => Str)
1063              
1064             Each argument is described in detail in: L<Paws::RedShift::DeleteHsmClientCertificate>
1065              
1066             Returns: nothing
1067              
1068             Deletes the specified HSM client certificate.
1069              
1070              
1071             =head2 DeleteHsmConfiguration(HsmConfigurationIdentifier => Str)
1072              
1073             Each argument is described in detail in: L<Paws::RedShift::DeleteHsmConfiguration>
1074              
1075             Returns: nothing
1076              
1077             Deletes the specified Amazon Redshift HSM configuration.
1078              
1079              
1080             =head2 DeleteSnapshotCopyGrant(SnapshotCopyGrantName => Str)
1081              
1082             Each argument is described in detail in: L<Paws::RedShift::DeleteSnapshotCopyGrant>
1083              
1084             Returns: nothing
1085              
1086             Deletes the specified snapshot copy grant.
1087              
1088              
1089             =head2 DeleteTags(ResourceName => Str, TagKeys => ArrayRef[Str|Undef])
1090              
1091             Each argument is described in detail in: L<Paws::RedShift::DeleteTags>
1092              
1093             Returns: nothing
1094              
1095             Deletes a tag or tags from a resource. You must provide the ARN of the
1096             resource from which you want to delete the tag or tags.
1097              
1098              
1099             =head2 DescribeClusterParameterGroups([Marker => Str, MaxRecords => Int, ParameterGroupName => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1100              
1101             Each argument is described in detail in: L<Paws::RedShift::DescribeClusterParameterGroups>
1102              
1103             Returns: a L<Paws::RedShift::ClusterParameterGroupsMessage> instance
1104              
1105             Returns a list of Amazon Redshift parameter groups, including parameter
1106             groups you created and the default parameter group. For each parameter
1107             group, the response includes the parameter group name, description, and
1108             parameter group family name. You can optionally specify a name to
1109             retrieve the description of a specific parameter group.
1110              
1111             For more information about parameters and parameter groups, go to
1112             Amazon Redshift Parameter Groups in the I<Amazon Redshift Cluster
1113             Management Guide>.
1114              
1115             If you specify both tag keys and tag values in the same request, Amazon
1116             Redshift returns all parameter groups that match any combination of the
1117             specified keys and values. For example, if you have C<owner> and
1118             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1119             all parameter groups that have any combination of those values are
1120             returned.
1121              
1122             If both tag keys and values are omitted from the request, parameter
1123             groups are returned regardless of whether they have tag keys or values
1124             associated with them.
1125              
1126              
1127             =head2 DescribeClusterParameters(ParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
1128              
1129             Each argument is described in detail in: L<Paws::RedShift::DescribeClusterParameters>
1130              
1131             Returns: a L<Paws::RedShift::ClusterParameterGroupDetails> instance
1132              
1133             Returns a detailed list of parameters contained within the specified
1134             Amazon Redshift parameter group. For each parameter the response
1135             includes information such as parameter name, description, data type,
1136             value, whether the parameter value is modifiable, and so on.
1137              
1138             You can specify I<source> filter to retrieve parameters of only
1139             specific type. For example, to retrieve parameters that were modified
1140             by a user action such as from ModifyClusterParameterGroup, you can
1141             specify I<source> equal to I<user>.
1142              
1143             For more information about parameters and parameter groups, go to
1144             Amazon Redshift Parameter Groups in the I<Amazon Redshift Cluster
1145             Management Guide>.
1146              
1147              
1148             =head2 DescribeClusters([ClusterIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1149              
1150             Each argument is described in detail in: L<Paws::RedShift::DescribeClusters>
1151              
1152             Returns: a L<Paws::RedShift::ClustersMessage> instance
1153              
1154             Returns properties of provisioned clusters including general cluster
1155             properties, cluster database properties, maintenance and backup
1156             properties, and security and access properties. This operation supports
1157             pagination. For more information about managing clusters, go to Amazon
1158             Redshift Clusters in the I<Amazon Redshift Cluster Management Guide>.
1159              
1160             If you specify both tag keys and tag values in the same request, Amazon
1161             Redshift returns all clusters that match any combination of the
1162             specified keys and values. For example, if you have C<owner> and
1163             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1164             all clusters that have any combination of those values are returned.
1165              
1166             If both tag keys and values are omitted from the request, clusters are
1167             returned regardless of whether they have tag keys or values associated
1168             with them.
1169              
1170              
1171             =head2 DescribeClusterSecurityGroups([ClusterSecurityGroupName => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1172              
1173             Each argument is described in detail in: L<Paws::RedShift::DescribeClusterSecurityGroups>
1174              
1175             Returns: a L<Paws::RedShift::ClusterSecurityGroupMessage> instance
1176              
1177             Returns information about Amazon Redshift security groups. If the name
1178             of a security group is specified, the response will contain only
1179             information about only that security group.
1180              
1181             For information about managing security groups, go to Amazon Redshift
1182             Cluster Security Groups in the I<Amazon Redshift Cluster Management
1183             Guide>.
1184              
1185             If you specify both tag keys and tag values in the same request, Amazon
1186             Redshift returns all security groups that match any combination of the
1187             specified keys and values. For example, if you have C<owner> and
1188             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1189             all security groups that have any combination of those values are
1190             returned.
1191              
1192             If both tag keys and values are omitted from the request, security
1193             groups are returned regardless of whether they have tag keys or values
1194             associated with them.
1195              
1196              
1197             =head2 DescribeClusterSnapshots([ClusterIdentifier => Str, EndTime => Str, Marker => Str, MaxRecords => Int, OwnerAccount => Str, SnapshotIdentifier => Str, SnapshotType => Str, StartTime => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1198              
1199             Each argument is described in detail in: L<Paws::RedShift::DescribeClusterSnapshots>
1200              
1201             Returns: a L<Paws::RedShift::SnapshotMessage> instance
1202              
1203             Returns one or more snapshot objects, which contain metadata about your
1204             cluster snapshots. By default, this operation returns information about
1205             all snapshots of all clusters that are owned by you AWS customer
1206             account. No information is returned for snapshots owned by inactive AWS
1207             customer accounts.
1208              
1209             If you specify both tag keys and tag values in the same request, Amazon
1210             Redshift returns all snapshots that match any combination of the
1211             specified keys and values. For example, if you have C<owner> and
1212             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1213             all snapshots that have any combination of those values are returned.
1214             Only snapshots that you own are returned in the response; shared
1215             snapshots are not returned with the tag key and tag value request
1216             parameters.
1217              
1218             If both tag keys and values are omitted from the request, snapshots are
1219             returned regardless of whether they have tag keys or values associated
1220             with them.
1221              
1222              
1223             =head2 DescribeClusterSubnetGroups([ClusterSubnetGroupName => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1224              
1225             Each argument is described in detail in: L<Paws::RedShift::DescribeClusterSubnetGroups>
1226              
1227             Returns: a L<Paws::RedShift::ClusterSubnetGroupMessage> instance
1228              
1229             Returns one or more cluster subnet group objects, which contain
1230             metadata about your cluster subnet groups. By default, this operation
1231             returns information about all cluster subnet groups that are defined in
1232             you AWS account.
1233              
1234             If you specify both tag keys and tag values in the same request, Amazon
1235             Redshift returns all subnet groups that match any combination of the
1236             specified keys and values. For example, if you have C<owner> and
1237             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1238             all subnet groups that have any combination of those values are
1239             returned.
1240              
1241             If both tag keys and values are omitted from the request, subnet groups
1242             are returned regardless of whether they have tag keys or values
1243             associated with them.
1244              
1245              
1246             =head2 DescribeClusterVersions([ClusterParameterGroupFamily => Str, ClusterVersion => Str, Marker => Str, MaxRecords => Int])
1247              
1248             Each argument is described in detail in: L<Paws::RedShift::DescribeClusterVersions>
1249              
1250             Returns: a L<Paws::RedShift::ClusterVersionsMessage> instance
1251              
1252             Returns descriptions of the available Amazon Redshift cluster versions.
1253             You can call this operation even before creating any clusters to learn
1254             more about the Amazon Redshift versions. For more information about
1255             managing clusters, go to Amazon Redshift Clusters in the I<Amazon
1256             Redshift Cluster Management Guide>.
1257              
1258              
1259             =head2 DescribeDefaultClusterParameters(ParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
1260              
1261             Each argument is described in detail in: L<Paws::RedShift::DescribeDefaultClusterParameters>
1262              
1263             Returns: a L<Paws::RedShift::DescribeDefaultClusterParametersResult> instance
1264              
1265             Returns a list of parameter settings for the specified parameter group
1266             family.
1267              
1268             For more information about parameters and parameter groups, go to
1269             Amazon Redshift Parameter Groups in the I<Amazon Redshift Cluster
1270             Management Guide>.
1271              
1272              
1273             =head2 DescribeEventCategories([SourceType => Str])
1274              
1275             Each argument is described in detail in: L<Paws::RedShift::DescribeEventCategories>
1276              
1277             Returns: a L<Paws::RedShift::EventCategoriesMessage> instance
1278              
1279             Displays a list of event categories for all event source types, or for
1280             a specified source type. For a list of the event categories and source
1281             types, go to Amazon Redshift Event Notifications.
1282              
1283              
1284             =head2 DescribeEvents([Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
1285              
1286             Each argument is described in detail in: L<Paws::RedShift::DescribeEvents>
1287              
1288             Returns: a L<Paws::RedShift::EventsMessage> instance
1289              
1290             Returns events related to clusters, security groups, snapshots, and
1291             parameter groups for the past 14 days. Events specific to a particular
1292             cluster, security group, snapshot or parameter group can be obtained by
1293             providing the name as a parameter. By default, the past hour of events
1294             are returned.
1295              
1296              
1297             =head2 DescribeEventSubscriptions([Marker => Str, MaxRecords => Int, SubscriptionName => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1298              
1299             Each argument is described in detail in: L<Paws::RedShift::DescribeEventSubscriptions>
1300              
1301             Returns: a L<Paws::RedShift::EventSubscriptionsMessage> instance
1302              
1303             Lists descriptions of all the Amazon Redshift event notification
1304             subscriptions for a customer account. If you specify a subscription
1305             name, lists the description for that subscription.
1306              
1307             If you specify both tag keys and tag values in the same request, Amazon
1308             Redshift returns all event notification subscriptions that match any
1309             combination of the specified keys and values. For example, if you have
1310             C<owner> and C<environment> for tag keys, and C<admin> and C<test> for
1311             tag values, all subscriptions that have any combination of those values
1312             are returned.
1313              
1314             If both tag keys and values are omitted from the request, subscriptions
1315             are returned regardless of whether they have tag keys or values
1316             associated with them.
1317              
1318              
1319             =head2 DescribeHsmClientCertificates([HsmClientCertificateIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1320              
1321             Each argument is described in detail in: L<Paws::RedShift::DescribeHsmClientCertificates>
1322              
1323             Returns: a L<Paws::RedShift::HsmClientCertificateMessage> instance
1324              
1325             Returns information about the specified HSM client certificate. If no
1326             certificate ID is specified, returns information about all the HSM
1327             certificates owned by your AWS customer account.
1328              
1329             If you specify both tag keys and tag values in the same request, Amazon
1330             Redshift returns all HSM client certificates that match any combination
1331             of the specified keys and values. For example, if you have C<owner> and
1332             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1333             all HSM client certificates that have any combination of those values
1334             are returned.
1335              
1336             If both tag keys and values are omitted from the request, HSM client
1337             certificates are returned regardless of whether they have tag keys or
1338             values associated with them.
1339              
1340              
1341             =head2 DescribeHsmConfigurations([HsmConfigurationIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1342              
1343             Each argument is described in detail in: L<Paws::RedShift::DescribeHsmConfigurations>
1344              
1345             Returns: a L<Paws::RedShift::HsmConfigurationMessage> instance
1346              
1347             Returns information about the specified Amazon Redshift HSM
1348             configuration. If no configuration ID is specified, returns information
1349             about all the HSM configurations owned by your AWS customer account.
1350              
1351             If you specify both tag keys and tag values in the same request, Amazon
1352             Redshift returns all HSM connections that match any combination of the
1353             specified keys and values. For example, if you have C<owner> and
1354             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1355             all HSM connections that have any combination of those values are
1356             returned.
1357              
1358             If both tag keys and values are omitted from the request, HSM
1359             connections are returned regardless of whether they have tag keys or
1360             values associated with them.
1361              
1362              
1363             =head2 DescribeLoggingStatus(ClusterIdentifier => Str)
1364              
1365             Each argument is described in detail in: L<Paws::RedShift::DescribeLoggingStatus>
1366              
1367             Returns: a L<Paws::RedShift::LoggingStatus> instance
1368              
1369             Describes whether information, such as queries and connection attempts,
1370             is being logged for the specified Amazon Redshift cluster.
1371              
1372              
1373             =head2 DescribeOrderableClusterOptions([ClusterVersion => Str, Marker => Str, MaxRecords => Int, NodeType => Str])
1374              
1375             Each argument is described in detail in: L<Paws::RedShift::DescribeOrderableClusterOptions>
1376              
1377             Returns: a L<Paws::RedShift::OrderableClusterOptionsMessage> instance
1378              
1379             Returns a list of orderable cluster options. Before you create a new
1380             cluster you can use this operation to find what options are available,
1381             such as the EC2 Availability Zones (AZ) in the specific AWS region that
1382             you can specify, and the node types you can request. The node types
1383             differ by available storage, memory, CPU and price. With the cost
1384             involved you might want to obtain a list of cluster options in the
1385             specific region and specify values when creating a cluster. For more
1386             information about managing clusters, go to Amazon Redshift Clusters in
1387             the I<Amazon Redshift Cluster Management Guide>.
1388              
1389              
1390             =head2 DescribeReservedNodeOfferings([Marker => Str, MaxRecords => Int, ReservedNodeOfferingId => Str])
1391              
1392             Each argument is described in detail in: L<Paws::RedShift::DescribeReservedNodeOfferings>
1393              
1394             Returns: a L<Paws::RedShift::ReservedNodeOfferingsMessage> instance
1395              
1396             Returns a list of the available reserved node offerings by Amazon
1397             Redshift with their descriptions including the node type, the fixed and
1398             recurring costs of reserving the node and duration the node will be
1399             reserved for you. These descriptions help you determine which reserve
1400             node offering you want to purchase. You then use the unique offering ID
1401             in you call to PurchaseReservedNodeOffering to reserve one or more
1402             nodes for your Amazon Redshift cluster.
1403              
1404             For more information about reserved node offerings, go to Purchasing
1405             Reserved Nodes in the I<Amazon Redshift Cluster Management Guide>.
1406              
1407              
1408             =head2 DescribeReservedNodes([Marker => Str, MaxRecords => Int, ReservedNodeId => Str])
1409              
1410             Each argument is described in detail in: L<Paws::RedShift::DescribeReservedNodes>
1411              
1412             Returns: a L<Paws::RedShift::ReservedNodesMessage> instance
1413              
1414             Returns the descriptions of the reserved nodes.
1415              
1416              
1417             =head2 DescribeResize(ClusterIdentifier => Str)
1418              
1419             Each argument is described in detail in: L<Paws::RedShift::DescribeResize>
1420              
1421             Returns: a L<Paws::RedShift::ResizeProgressMessage> instance
1422              
1423             Returns information about the last resize operation for the specified
1424             cluster. If no resize operation has ever been initiated for the
1425             specified cluster, a C<HTTP 404> error is returned. If a resize
1426             operation was initiated and completed, the status of the resize remains
1427             as C<SUCCEEDED> until the next resize.
1428              
1429             A resize operation can be requested using ModifyCluster and specifying
1430             a different number or type of nodes for the cluster.
1431              
1432              
1433             =head2 DescribeSnapshotCopyGrants([Marker => Str, MaxRecords => Int, SnapshotCopyGrantName => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1434              
1435             Each argument is described in detail in: L<Paws::RedShift::DescribeSnapshotCopyGrants>
1436              
1437             Returns: a L<Paws::RedShift::SnapshotCopyGrantMessage> instance
1438              
1439             Returns a list of snapshot copy grants owned by the AWS account in the
1440             destination region.
1441              
1442             For more information about managing snapshot copy grants, go to Amazon
1443             Redshift Database Encryption in the I<Amazon Redshift Cluster
1444             Management Guide>.
1445              
1446              
1447             =head2 DescribeTableRestoreStatus([ClusterIdentifier => Str, Marker => Str, MaxRecords => Int, TableRestoreRequestId => Str])
1448              
1449             Each argument is described in detail in: L<Paws::RedShift::DescribeTableRestoreStatus>
1450              
1451             Returns: a L<Paws::RedShift::TableRestoreStatusMessage> instance
1452              
1453             Lists the status of one or more table restore requests made using the
1454             RestoreTableFromClusterSnapshot API action. If you don't specify a
1455             value for the C<TableRestoreRequestId> parameter, then
1456             C<DescribeTableRestoreStatus> returns the status of all table restore
1457             requests ordered by the date and time of the request in ascending
1458             order. Otherwise C<DescribeTableRestoreStatus> returns the status of
1459             the table specified by C<TableRestoreRequestId>.
1460              
1461              
1462             =head2 DescribeTags([Marker => Str, MaxRecords => Int, ResourceName => Str, ResourceType => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1463              
1464             Each argument is described in detail in: L<Paws::RedShift::DescribeTags>
1465              
1466             Returns: a L<Paws::RedShift::TaggedResourceListMessage> instance
1467              
1468             Returns a list of tags. You can return tags from a specific resource by
1469             specifying an ARN, or you can return all tags for a given type of
1470             resource, such as clusters, snapshots, and so on.
1471              
1472             The following are limitations for C<DescribeTags>:
1473              
1474             =over
1475              
1476             =item *
1477              
1478             You cannot specify an ARN and a resource-type value together in the
1479             same request.
1480              
1481             =item *
1482              
1483             You cannot use the C<MaxRecords> and C<Marker> parameters together with
1484             the ARN parameter.
1485              
1486             =item *
1487              
1488             The C<MaxRecords> parameter can be a range from 10 to 50 results to
1489             return in a request.
1490              
1491             =back
1492              
1493             If you specify both tag keys and tag values in the same request, Amazon
1494             Redshift returns all resources that match any combination of the
1495             specified keys and values. For example, if you have C<owner> and
1496             C<environment> for tag keys, and C<admin> and C<test> for tag values,
1497             all resources that have any combination of those values are returned.
1498              
1499             If both tag keys and values are omitted from the request, resources are
1500             returned regardless of whether they have tag keys or values associated
1501             with them.
1502              
1503              
1504             =head2 DisableLogging(ClusterIdentifier => Str)
1505              
1506             Each argument is described in detail in: L<Paws::RedShift::DisableLogging>
1507              
1508             Returns: a L<Paws::RedShift::LoggingStatus> instance
1509              
1510             Stops logging information, such as queries and connection attempts, for
1511             the specified Amazon Redshift cluster.
1512              
1513              
1514             =head2 DisableSnapshotCopy(ClusterIdentifier => Str)
1515              
1516             Each argument is described in detail in: L<Paws::RedShift::DisableSnapshotCopy>
1517              
1518             Returns: a L<Paws::RedShift::DisableSnapshotCopyResult> instance
1519              
1520             Disables the automatic copying of snapshots from one region to another
1521             region for a specified cluster.
1522              
1523             If your cluster and its snapshots are encrypted using a customer master
1524             key (CMK) from AWS KMS, use DeleteSnapshotCopyGrant to delete the grant
1525             that grants Amazon Redshift permission to the CMK in the destination
1526             region.
1527              
1528              
1529             =head2 EnableLogging(BucketName => Str, ClusterIdentifier => Str, [S3KeyPrefix => Str])
1530              
1531             Each argument is described in detail in: L<Paws::RedShift::EnableLogging>
1532              
1533             Returns: a L<Paws::RedShift::LoggingStatus> instance
1534              
1535             Starts logging information, such as queries and connection attempts,
1536             for the specified Amazon Redshift cluster.
1537              
1538              
1539             =head2 EnableSnapshotCopy(ClusterIdentifier => Str, DestinationRegion => Str, [RetentionPeriod => Int, SnapshotCopyGrantName => Str])
1540              
1541             Each argument is described in detail in: L<Paws::RedShift::EnableSnapshotCopy>
1542              
1543             Returns: a L<Paws::RedShift::EnableSnapshotCopyResult> instance
1544              
1545             Enables the automatic copy of snapshots from one region to another
1546             region for a specified cluster.
1547              
1548              
1549             =head2 GetClusterCredentials(ClusterIdentifier => Str, DbUser => Str, [AutoCreate => Bool, DbGroups => ArrayRef[Str|Undef], DbName => Str, DurationSeconds => Int])
1550              
1551             Each argument is described in detail in: L<Paws::RedShift::GetClusterCredentials>
1552              
1553             Returns: a L<Paws::RedShift::ClusterCredentials> instance
1554              
1555             Returns a database user name and temporary password with temporary
1556             authorization to log on to an Amazon Redshift database. The action
1557             returns the database user name prefixed with C<IAM:> if C<AutoCreate>
1558             is C<False> or C<IAMA:> if C<AutoCreate> is C<True>. You can optionally
1559             specify one or more database user groups that the user will join at log
1560             on. By default, the temporary credentials expire in 900 seconds. You
1561             can optionally specify a duration between 900 seconds (15 minutes) and
1562             3600 seconds (60 minutes). For more information, see Using IAM
1563             Authentication to Generate Database User Credentials in the Amazon
1564             Redshift Cluster Management Guide.
1565              
1566             The AWS Identity and Access Management (IAM)user or role that executes
1567             GetClusterCredentials must have an IAM policy attached that allows
1568             access to all necessary actions and resources. For more information
1569             about permissions, see Resource Policies for GetClusterCredentials in
1570             the Amazon Redshift Cluster Management Guide.
1571              
1572             If the C<DbGroups> parameter is specified, the IAM policy must allow
1573             the C<redshift:JoinGroup> action with access to the listed C<dbgroups>.
1574              
1575             In addition, if the C<AutoCreate> parameter is set to C<True>, then the
1576             policy must include the C<redshift:CreateClusterUser> privilege.
1577              
1578             If the C<DbName> parameter is specified, the IAM policy must allow
1579             access to the resource C<dbname> for the specified database name.
1580              
1581              
1582             =head2 ModifyCluster(ClusterIdentifier => Str, [AllowVersionUpgrade => Bool, AutomatedSnapshotRetentionPeriod => Int, ClusterParameterGroupName => Str, ClusterSecurityGroups => ArrayRef[Str|Undef], ClusterType => Str, ClusterVersion => Str, ElasticIp => Str, EnhancedVpcRouting => Bool, HsmClientCertificateIdentifier => Str, HsmConfigurationIdentifier => Str, MasterUserPassword => Str, NewClusterIdentifier => Str, NodeType => Str, NumberOfNodes => Int, PreferredMaintenanceWindow => Str, PubliclyAccessible => Bool, VpcSecurityGroupIds => ArrayRef[Str|Undef]])
1583              
1584             Each argument is described in detail in: L<Paws::RedShift::ModifyCluster>
1585              
1586             Returns: a L<Paws::RedShift::ModifyClusterResult> instance
1587              
1588             Modifies the settings for a cluster. For example, you can add another
1589             security or parameter group, update the preferred maintenance window,
1590             or change the master user password. Resetting a cluster password or
1591             modifying the security groups associated with a cluster do not need a
1592             reboot. However, modifying a parameter group requires a reboot for
1593             parameters to take effect. For more information about managing
1594             clusters, go to Amazon Redshift Clusters in the I<Amazon Redshift
1595             Cluster Management Guide>.
1596              
1597             You can also change node type and the number of nodes to scale up or
1598             down the cluster. When resizing a cluster, you must specify both the
1599             number of nodes and the node type even if one of the parameters does
1600             not change.
1601              
1602              
1603             =head2 ModifyClusterIamRoles(ClusterIdentifier => Str, [AddIamRoles => ArrayRef[Str|Undef], RemoveIamRoles => ArrayRef[Str|Undef]])
1604              
1605             Each argument is described in detail in: L<Paws::RedShift::ModifyClusterIamRoles>
1606              
1607             Returns: a L<Paws::RedShift::ModifyClusterIamRolesResult> instance
1608              
1609             Modifies the list of AWS Identity and Access Management (IAM) roles
1610             that can be used by the cluster to access other AWS services.
1611              
1612             A cluster can have up to 10 IAM roles associated at any time.
1613              
1614              
1615             =head2 ModifyClusterParameterGroup(ParameterGroupName => Str, Parameters => ArrayRef[L<Paws::RedShift::Parameter>])
1616              
1617             Each argument is described in detail in: L<Paws::RedShift::ModifyClusterParameterGroup>
1618              
1619             Returns: a L<Paws::RedShift::ClusterParameterGroupNameMessage> instance
1620              
1621             Modifies the parameters of a parameter group.
1622              
1623             For more information about parameters and parameter groups, go to
1624             Amazon Redshift Parameter Groups in the I<Amazon Redshift Cluster
1625             Management Guide>.
1626              
1627              
1628             =head2 ModifyClusterSubnetGroup(ClusterSubnetGroupName => Str, SubnetIds => ArrayRef[Str|Undef], [Description => Str])
1629              
1630             Each argument is described in detail in: L<Paws::RedShift::ModifyClusterSubnetGroup>
1631              
1632             Returns: a L<Paws::RedShift::ModifyClusterSubnetGroupResult> instance
1633              
1634             Modifies a cluster subnet group to include the specified list of VPC
1635             subnets. The operation replaces the existing list of subnets with the
1636             new list of subnets.
1637              
1638              
1639             =head2 ModifyEventSubscription(SubscriptionName => Str, [Enabled => Bool, EventCategories => ArrayRef[Str|Undef], Severity => Str, SnsTopicArn => Str, SourceIds => ArrayRef[Str|Undef], SourceType => Str])
1640              
1641             Each argument is described in detail in: L<Paws::RedShift::ModifyEventSubscription>
1642              
1643             Returns: a L<Paws::RedShift::ModifyEventSubscriptionResult> instance
1644              
1645             Modifies an existing Amazon Redshift event notification subscription.
1646              
1647              
1648             =head2 ModifySnapshotCopyRetentionPeriod(ClusterIdentifier => Str, RetentionPeriod => Int)
1649              
1650             Each argument is described in detail in: L<Paws::RedShift::ModifySnapshotCopyRetentionPeriod>
1651              
1652             Returns: a L<Paws::RedShift::ModifySnapshotCopyRetentionPeriodResult> instance
1653              
1654             Modifies the number of days to retain automated snapshots in the
1655             destination region after they are copied from the source region.
1656              
1657              
1658             =head2 PurchaseReservedNodeOffering(ReservedNodeOfferingId => Str, [NodeCount => Int])
1659              
1660             Each argument is described in detail in: L<Paws::RedShift::PurchaseReservedNodeOffering>
1661              
1662             Returns: a L<Paws::RedShift::PurchaseReservedNodeOfferingResult> instance
1663              
1664             Allows you to purchase reserved nodes. Amazon Redshift offers a
1665             predefined set of reserved node offerings. You can purchase one or more
1666             of the offerings. You can call the DescribeReservedNodeOfferings API to
1667             obtain the available reserved node offerings. You can call this API by
1668             providing a specific reserved node offering and the number of nodes you
1669             want to reserve.
1670              
1671             For more information about reserved node offerings, go to Purchasing
1672             Reserved Nodes in the I<Amazon Redshift Cluster Management Guide>.
1673              
1674              
1675             =head2 RebootCluster(ClusterIdentifier => Str)
1676              
1677             Each argument is described in detail in: L<Paws::RedShift::RebootCluster>
1678              
1679             Returns: a L<Paws::RedShift::RebootClusterResult> instance
1680              
1681             Reboots a cluster. This action is taken as soon as possible. It results
1682             in a momentary outage to the cluster, during which the cluster status
1683             is set to C<rebooting>. A cluster event is created when the reboot is
1684             completed. Any pending cluster modifications (see ModifyCluster) are
1685             applied at this reboot. For more information about managing clusters,
1686             go to Amazon Redshift Clusters in the I<Amazon Redshift Cluster
1687             Management Guide>.
1688              
1689              
1690             =head2 ResetClusterParameterGroup(ParameterGroupName => Str, [Parameters => ArrayRef[L<Paws::RedShift::Parameter>], ResetAllParameters => Bool])
1691              
1692             Each argument is described in detail in: L<Paws::RedShift::ResetClusterParameterGroup>
1693              
1694             Returns: a L<Paws::RedShift::ClusterParameterGroupNameMessage> instance
1695              
1696             Sets one or more parameters of the specified parameter group to their
1697             default values and sets the source values of the parameters to
1698             "engine-default". To reset the entire parameter group specify the
1699             I<ResetAllParameters> parameter. For parameter changes to take effect
1700             you must reboot any associated clusters.
1701              
1702              
1703             =head2 RestoreFromClusterSnapshot(ClusterIdentifier => Str, SnapshotIdentifier => Str, [AdditionalInfo => Str, AllowVersionUpgrade => Bool, AutomatedSnapshotRetentionPeriod => Int, AvailabilityZone => Str, ClusterParameterGroupName => Str, ClusterSecurityGroups => ArrayRef[Str|Undef], ClusterSubnetGroupName => Str, ElasticIp => Str, EnhancedVpcRouting => Bool, HsmClientCertificateIdentifier => Str, HsmConfigurationIdentifier => Str, IamRoles => ArrayRef[Str|Undef], KmsKeyId => Str, NodeType => Str, OwnerAccount => Str, Port => Int, PreferredMaintenanceWindow => Str, PubliclyAccessible => Bool, SnapshotClusterIdentifier => Str, VpcSecurityGroupIds => ArrayRef[Str|Undef]])
1704              
1705             Each argument is described in detail in: L<Paws::RedShift::RestoreFromClusterSnapshot>
1706              
1707             Returns: a L<Paws::RedShift::RestoreFromClusterSnapshotResult> instance
1708              
1709             Creates a new cluster from a snapshot. By default, Amazon Redshift
1710             creates the resulting cluster with the same configuration as the
1711             original cluster from which the snapshot was created, except that the
1712             new cluster is created with the default cluster security and parameter
1713             groups. After Amazon Redshift creates the cluster, you can use the
1714             ModifyCluster API to associate a different security group and different
1715             parameter group with the restored cluster. If you are using a DS node
1716             type, you can also choose to change to another DS node type of the same
1717             size during restore.
1718              
1719             If you restore a cluster into a VPC, you must provide a cluster subnet
1720             group where you want the cluster restored.
1721              
1722             For more information about working with snapshots, go to Amazon
1723             Redshift Snapshots in the I<Amazon Redshift Cluster Management Guide>.
1724              
1725              
1726             =head2 RestoreTableFromClusterSnapshot(ClusterIdentifier => Str, NewTableName => Str, SnapshotIdentifier => Str, SourceDatabaseName => Str, SourceTableName => Str, [SourceSchemaName => Str, TargetDatabaseName => Str, TargetSchemaName => Str])
1727              
1728             Each argument is described in detail in: L<Paws::RedShift::RestoreTableFromClusterSnapshot>
1729              
1730             Returns: a L<Paws::RedShift::RestoreTableFromClusterSnapshotResult> instance
1731              
1732             Creates a new table from a table in an Amazon Redshift cluster
1733             snapshot. You must create the new table within the Amazon Redshift
1734             cluster that the snapshot was taken from.
1735              
1736             You cannot use C<RestoreTableFromClusterSnapshot> to restore a table
1737             with the same name as an existing table in an Amazon Redshift cluster.
1738             That is, you cannot overwrite an existing table in a cluster with a
1739             restored table. If you want to replace your original table with a new,
1740             restored table, then rename or drop your original table before you call
1741             C<RestoreTableFromClusterSnapshot>. When you have renamed your original
1742             table, then you can pass the original name of the table as the
1743             C<NewTableName> parameter value in the call to
1744             C<RestoreTableFromClusterSnapshot>. This way, you can replace the
1745             original table with the table created from the snapshot.
1746              
1747              
1748             =head2 RevokeClusterSecurityGroupIngress(ClusterSecurityGroupName => Str, [CIDRIP => Str, EC2SecurityGroupName => Str, EC2SecurityGroupOwnerId => Str])
1749              
1750             Each argument is described in detail in: L<Paws::RedShift::RevokeClusterSecurityGroupIngress>
1751              
1752             Returns: a L<Paws::RedShift::RevokeClusterSecurityGroupIngressResult> instance
1753              
1754             Revokes an ingress rule in an Amazon Redshift security group for a
1755             previously authorized IP range or Amazon EC2 security group. To add an
1756             ingress rule, see AuthorizeClusterSecurityGroupIngress. For information
1757             about managing security groups, go to Amazon Redshift Cluster Security
1758             Groups in the I<Amazon Redshift Cluster Management Guide>.
1759              
1760              
1761             =head2 RevokeSnapshotAccess(AccountWithRestoreAccess => Str, SnapshotIdentifier => Str, [SnapshotClusterIdentifier => Str])
1762              
1763             Each argument is described in detail in: L<Paws::RedShift::RevokeSnapshotAccess>
1764              
1765             Returns: a L<Paws::RedShift::RevokeSnapshotAccessResult> instance
1766              
1767             Removes the ability of the specified AWS customer account to restore
1768             the specified snapshot. If the account is currently restoring the
1769             snapshot, the restore will run to completion.
1770              
1771             For more information about working with snapshots, go to Amazon
1772             Redshift Snapshots in the I<Amazon Redshift Cluster Management Guide>.
1773              
1774              
1775             =head2 RotateEncryptionKey(ClusterIdentifier => Str)
1776              
1777             Each argument is described in detail in: L<Paws::RedShift::RotateEncryptionKey>
1778              
1779             Returns: a L<Paws::RedShift::RotateEncryptionKeyResult> instance
1780              
1781             Rotates the encryption keys for a cluster.
1782              
1783              
1784              
1785              
1786             =head1 PAGINATORS
1787              
1788             Paginator methods are helpers that repetively call methods that return partial results
1789              
1790             =head2 DescribeAllClusterParameterGroups(sub { },[Marker => Str, MaxRecords => Int, ParameterGroupName => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1791              
1792             =head2 DescribeAllClusterParameterGroups([Marker => Str, MaxRecords => Int, ParameterGroupName => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1793              
1794              
1795             If passed a sub as first parameter, it will call the sub for each element found in :
1796              
1797             - ParameterGroups, passing the object as the first parameter, and the string 'ParameterGroups' as the second parameter
1798              
1799             If not, it will return a a L<Paws::RedShift::ClusterParameterGroupsMessage> 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.
1800              
1801              
1802             =head2 DescribeAllClusterParameters(sub { },ParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
1803              
1804             =head2 DescribeAllClusterParameters(ParameterGroupName => Str, [Marker => Str, MaxRecords => Int, Source => Str])
1805              
1806              
1807             If passed a sub as first parameter, it will call the sub for each element found in :
1808              
1809             - Parameters, passing the object as the first parameter, and the string 'Parameters' as the second parameter
1810              
1811             If not, it will return a a L<Paws::RedShift::ClusterParameterGroupDetails> 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.
1812              
1813              
1814             =head2 DescribeAllClusters(sub { },[ClusterIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1815              
1816             =head2 DescribeAllClusters([ClusterIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1817              
1818              
1819             If passed a sub as first parameter, it will call the sub for each element found in :
1820              
1821             - Clusters, passing the object as the first parameter, and the string 'Clusters' as the second parameter
1822              
1823             If not, it will return a a L<Paws::RedShift::ClustersMessage> 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.
1824              
1825              
1826             =head2 DescribeAllClusterSecurityGroups(sub { },[ClusterSecurityGroupName => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1827              
1828             =head2 DescribeAllClusterSecurityGroups([ClusterSecurityGroupName => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1829              
1830              
1831             If passed a sub as first parameter, it will call the sub for each element found in :
1832              
1833             - ClusterSecurityGroups, passing the object as the first parameter, and the string 'ClusterSecurityGroups' as the second parameter
1834              
1835             If not, it will return a a L<Paws::RedShift::ClusterSecurityGroupMessage> 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.
1836              
1837              
1838             =head2 DescribeAllClusterSnapshots(sub { },[ClusterIdentifier => Str, EndTime => Str, Marker => Str, MaxRecords => Int, OwnerAccount => Str, SnapshotIdentifier => Str, SnapshotType => Str, StartTime => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1839              
1840             =head2 DescribeAllClusterSnapshots([ClusterIdentifier => Str, EndTime => Str, Marker => Str, MaxRecords => Int, OwnerAccount => Str, SnapshotIdentifier => Str, SnapshotType => Str, StartTime => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1841              
1842              
1843             If passed a sub as first parameter, it will call the sub for each element found in :
1844              
1845             - Snapshots, passing the object as the first parameter, and the string 'Snapshots' as the second parameter
1846              
1847             If not, it will return a a L<Paws::RedShift::SnapshotMessage> 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.
1848              
1849              
1850             =head2 DescribeAllClusterSubnetGroups(sub { },[ClusterSubnetGroupName => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1851              
1852             =head2 DescribeAllClusterSubnetGroups([ClusterSubnetGroupName => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1853              
1854              
1855             If passed a sub as first parameter, it will call the sub for each element found in :
1856              
1857             - ClusterSubnetGroups, passing the object as the first parameter, and the string 'ClusterSubnetGroups' as the second parameter
1858              
1859             If not, it will return a a L<Paws::RedShift::ClusterSubnetGroupMessage> 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.
1860              
1861              
1862             =head2 DescribeAllClusterVersions(sub { },[ClusterParameterGroupFamily => Str, ClusterVersion => Str, Marker => Str, MaxRecords => Int])
1863              
1864             =head2 DescribeAllClusterVersions([ClusterParameterGroupFamily => Str, ClusterVersion => Str, Marker => Str, MaxRecords => Int])
1865              
1866              
1867             If passed a sub as first parameter, it will call the sub for each element found in :
1868              
1869             - ClusterVersions, passing the object as the first parameter, and the string 'ClusterVersions' as the second parameter
1870              
1871             If not, it will return a a L<Paws::RedShift::ClusterVersionsMessage> 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.
1872              
1873              
1874             =head2 DescribeAllDefaultClusterParameters(sub { },ParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
1875              
1876             =head2 DescribeAllDefaultClusterParameters(ParameterGroupFamily => Str, [Marker => Str, MaxRecords => Int])
1877              
1878              
1879             If passed a sub as first parameter, it will call the sub for each element found in :
1880              
1881             - DefaultClusterParameters.Parameters, passing the object as the first parameter, and the string 'DefaultClusterParameters.Parameters' as the second parameter
1882              
1883             If not, it will return a a L<Paws::RedShift::DescribeDefaultClusterParametersResult> 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.
1884              
1885              
1886             =head2 DescribeAllEvents(sub { },[Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
1887              
1888             =head2 DescribeAllEvents([Duration => Int, EndTime => Str, Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
1889              
1890              
1891             If passed a sub as first parameter, it will call the sub for each element found in :
1892              
1893             - Events, passing the object as the first parameter, and the string 'Events' as the second parameter
1894              
1895             If not, it will return a a L<Paws::RedShift::EventsMessage> 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.
1896              
1897              
1898             =head2 DescribeAllEventSubscriptions(sub { },[Marker => Str, MaxRecords => Int, SubscriptionName => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1899              
1900             =head2 DescribeAllEventSubscriptions([Marker => Str, MaxRecords => Int, SubscriptionName => Str, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1901              
1902              
1903             If passed a sub as first parameter, it will call the sub for each element found in :
1904              
1905             - EventSubscriptionsList, passing the object as the first parameter, and the string 'EventSubscriptionsList' as the second parameter
1906              
1907             If not, it will return a a L<Paws::RedShift::EventSubscriptionsMessage> 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.
1908              
1909              
1910             =head2 DescribeAllHsmClientCertificates(sub { },[HsmClientCertificateIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1911              
1912             =head2 DescribeAllHsmClientCertificates([HsmClientCertificateIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1913              
1914              
1915             If passed a sub as first parameter, it will call the sub for each element found in :
1916              
1917             - HsmClientCertificates, passing the object as the first parameter, and the string 'HsmClientCertificates' as the second parameter
1918              
1919             If not, it will return a a L<Paws::RedShift::HsmClientCertificateMessage> 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.
1920              
1921              
1922             =head2 DescribeAllHsmConfigurations(sub { },[HsmConfigurationIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1923              
1924             =head2 DescribeAllHsmConfigurations([HsmConfigurationIdentifier => Str, Marker => Str, MaxRecords => Int, TagKeys => ArrayRef[Str|Undef], TagValues => ArrayRef[Str|Undef]])
1925              
1926              
1927             If passed a sub as first parameter, it will call the sub for each element found in :
1928              
1929             - HsmConfigurations, passing the object as the first parameter, and the string 'HsmConfigurations' as the second parameter
1930              
1931             If not, it will return a a L<Paws::RedShift::HsmConfigurationMessage> 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.
1932              
1933              
1934             =head2 DescribeAllOrderableClusterOptions(sub { },[ClusterVersion => Str, Marker => Str, MaxRecords => Int, NodeType => Str])
1935              
1936             =head2 DescribeAllOrderableClusterOptions([ClusterVersion => Str, Marker => Str, MaxRecords => Int, NodeType => Str])
1937              
1938              
1939             If passed a sub as first parameter, it will call the sub for each element found in :
1940              
1941             - OrderableClusterOptions, passing the object as the first parameter, and the string 'OrderableClusterOptions' as the second parameter
1942              
1943             If not, it will return a a L<Paws::RedShift::OrderableClusterOptionsMessage> 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.
1944              
1945              
1946             =head2 DescribeAllReservedNodeOfferings(sub { },[Marker => Str, MaxRecords => Int, ReservedNodeOfferingId => Str])
1947              
1948             =head2 DescribeAllReservedNodeOfferings([Marker => Str, MaxRecords => Int, ReservedNodeOfferingId => Str])
1949              
1950              
1951             If passed a sub as first parameter, it will call the sub for each element found in :
1952              
1953             - ReservedNodeOfferings, passing the object as the first parameter, and the string 'ReservedNodeOfferings' as the second parameter
1954              
1955             If not, it will return a a L<Paws::RedShift::ReservedNodeOfferingsMessage> 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.
1956              
1957              
1958             =head2 DescribeAllReservedNodes(sub { },[Marker => Str, MaxRecords => Int, ReservedNodeId => Str])
1959              
1960             =head2 DescribeAllReservedNodes([Marker => Str, MaxRecords => Int, ReservedNodeId => Str])
1961              
1962              
1963             If passed a sub as first parameter, it will call the sub for each element found in :
1964              
1965             - ReservedNodes, passing the object as the first parameter, and the string 'ReservedNodes' as the second parameter
1966              
1967             If not, it will return a a L<Paws::RedShift::ReservedNodesMessage> 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.
1968              
1969              
1970              
1971              
1972              
1973             =head1 SEE ALSO
1974              
1975             This service class forms part of L<Paws>
1976              
1977             =head1 BUGS and CONTRIBUTIONS
1978              
1979             The source code is located here: https://github.com/pplu/aws-sdk-perl
1980              
1981             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
1982              
1983             =cut
1984