blib/lib/Paws/Neptune.pm untested

filter: Statementstmt 0.0% 0 / 509 Branchbran 0.0% 0 / 60 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 84 Podpod 0.0% 0 / 83 totaltotal 0.0% 0 / 736 CC 31 SCAR 17.8
CC
31
Cov
0%
DescribeAllDBClusterEndpoints
12.0
DescribeAllDBClusterParameterGroups
12.0
DescribeAllDBClusterParameters
12.0
CRAP 5.9
1 package Paws::Neptune;
2 use Moose;
3 sub service { 'rds' }
4 sub signing_name { 'rds' }
5 sub version { '2014-10-31' }
6 sub flattened_arrays { 0 }
7 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 has retry => (is => 'ro', isa => 'HashRef', default => sub {
9 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 });
11 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12 ] });
13  
14 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::QueryCaller';
15  
16 has '+region_rules' => (default => sub {
17 my $regioninfo;
18 $regioninfo = [
19 {
20 constraints => [
21 [
22 'region',
23 'equals',
24 'us-east-1'
25 ]
26 ],
27 uri => 'https://rds.amazonaws.com'
28 }
29 ];
30  
31 return $regioninfo;
32 });
33  
34
35 sub AddRoleToDBCluster {
36 my $self = shift;
37 my $call_object = $self->new_with_coercions('Paws::Neptune::AddRoleToDBCluster', @_);
38 return $self->caller->do_call($self, $call_object);
39 }
40 sub AddSourceIdentifierToSubscription {
41 my $self = shift;
42 my $call_object = $self->new_with_coercions('Paws::Neptune::AddSourceIdentifierToSubscription', @_);
43 return $self->caller->do_call($self, $call_object);
44 }
45 sub AddTagsToResource {
46 my $self = shift;
47 my $call_object = $self->new_with_coercions('Paws::Neptune::AddTagsToResource', @_);
48 return $self->caller->do_call($self, $call_object);
49 }
50 sub ApplyPendingMaintenanceAction {
51 my $self = shift;
52 my $call_object = $self->new_with_coercions('Paws::Neptune::ApplyPendingMaintenanceAction', @_);
53 return $self->caller->do_call($self, $call_object);
54 }
55 sub CopyDBClusterParameterGroup {
56 my $self = shift;
57 my $call_object = $self->new_with_coercions('Paws::Neptune::CopyDBClusterParameterGroup', @_);
58 return $self->caller->do_call($self, $call_object);
59 }
60 sub CopyDBClusterSnapshot {
61 my $self = shift;
62 my $call_object = $self->new_with_coercions('Paws::Neptune::CopyDBClusterSnapshot', @_);
63 return $self->caller->do_call($self, $call_object);
64 }
65 sub CopyDBParameterGroup {
66 my $self = shift;
67 my $call_object = $self->new_with_coercions('Paws::Neptune::CopyDBParameterGroup', @_);
68 return $self->caller->do_call($self, $call_object);
69 }
70 sub CreateDBCluster {
71 my $self = shift;
72 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateDBCluster', @_);
73 return $self->caller->do_call($self, $call_object);
74 }
75 sub CreateDBClusterEndpoint {
76 my $self = shift;
77 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateDBClusterEndpoint', @_);
78 return $self->caller->do_call($self, $call_object);
79 }
80 sub CreateDBClusterParameterGroup {
81 my $self = shift;
82 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateDBClusterParameterGroup', @_);
83 return $self->caller->do_call($self, $call_object);
84 }
85 sub CreateDBClusterSnapshot {
86 my $self = shift;
87 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateDBClusterSnapshot', @_);
88 return $self->caller->do_call($self, $call_object);
89 }
90 sub CreateDBInstance {
91 my $self = shift;
92 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateDBInstance', @_);
93 return $self->caller->do_call($self, $call_object);
94 }
95 sub CreateDBParameterGroup {
96 my $self = shift;
97 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateDBParameterGroup', @_);
98 return $self->caller->do_call($self, $call_object);
99 }
100 sub CreateDBSubnetGroup {
101 my $self = shift;
102 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateDBSubnetGroup', @_);
103 return $self->caller->do_call($self, $call_object);
104 }
105 sub CreateEventSubscription {
106 my $self = shift;
107 my $call_object = $self->new_with_coercions('Paws::Neptune::CreateEventSubscription', @_);
108 return $self->caller->do_call($self, $call_object);
109 }
110 sub DeleteDBCluster {
111 my $self = shift;
112 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteDBCluster', @_);
113 return $self->caller->do_call($self, $call_object);
114 }
115 sub DeleteDBClusterEndpoint {
116 my $self = shift;
117 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteDBClusterEndpoint', @_);
118 return $self->caller->do_call($self, $call_object);
119 }
120 sub DeleteDBClusterParameterGroup {
121 my $self = shift;
122 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteDBClusterParameterGroup', @_);
123 return $self->caller->do_call($self, $call_object);
124 }
125 sub DeleteDBClusterSnapshot {
126 my $self = shift;
127 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteDBClusterSnapshot', @_);
128 return $self->caller->do_call($self, $call_object);
129 }
130 sub DeleteDBInstance {
131 my $self = shift;
132 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteDBInstance', @_);
133 return $self->caller->do_call($self, $call_object);
134 }
135 sub DeleteDBParameterGroup {
136 my $self = shift;
137 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteDBParameterGroup', @_);
138 return $self->caller->do_call($self, $call_object);
139 }
140 sub DeleteDBSubnetGroup {
141 my $self = shift;
142 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteDBSubnetGroup', @_);
143 return $self->caller->do_call($self, $call_object);
144 }
145 sub DeleteEventSubscription {
146 my $self = shift;
147 my $call_object = $self->new_with_coercions('Paws::Neptune::DeleteEventSubscription', @_);
148 return $self->caller->do_call($self, $call_object);
149 }
150 sub DescribeDBClusterEndpoints {
151 my $self = shift;
152 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBClusterEndpoints', @_);
153 return $self->caller->do_call($self, $call_object);
154 }
155 sub DescribeDBClusterParameterGroups {
156 my $self = shift;
157 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBClusterParameterGroups', @_);
158 return $self->caller->do_call($self, $call_object);
159 }
160 sub DescribeDBClusterParameters {
161 my $self = shift;
162 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBClusterParameters', @_);
163 return $self->caller->do_call($self, $call_object);
164 }
165 sub DescribeDBClusters {
166 my $self = shift;
167 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBClusters', @_);
168 return $self->caller->do_call($self, $call_object);
169 }
170 sub DescribeDBClusterSnapshotAttributes {
171 my $self = shift;
172 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBClusterSnapshotAttributes', @_);
173 return $self->caller->do_call($self, $call_object);
174 }
175 sub DescribeDBClusterSnapshots {
176 my $self = shift;
177 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBClusterSnapshots', @_);
178 return $self->caller->do_call($self, $call_object);
179 }
180 sub DescribeDBEngineVersions {
181 my $self = shift;
182 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBEngineVersions', @_);
183 return $self->caller->do_call($self, $call_object);
184 }
185 sub DescribeDBInstances {
186 my $self = shift;
187 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBInstances', @_);
188 return $self->caller->do_call($self, $call_object);
189 }
190 sub DescribeDBParameterGroups {
191 my $self = shift;
192 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBParameterGroups', @_);
193 return $self->caller->do_call($self, $call_object);
194 }
195 sub DescribeDBParameters {
196 my $self = shift;
197 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBParameters', @_);
198 return $self->caller->do_call($self, $call_object);
199 }
200 sub DescribeDBSubnetGroups {
201 my $self = shift;
202 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeDBSubnetGroups', @_);
203 return $self->caller->do_call($self, $call_object);
204 }
205 sub DescribeEngineDefaultClusterParameters {
206 my $self = shift;
207 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeEngineDefaultClusterParameters', @_);
208 return $self->caller->do_call($self, $call_object);
209 }
210 sub DescribeEngineDefaultParameters {
211 my $self = shift;
212 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeEngineDefaultParameters', @_);
213 return $self->caller->do_call($self, $call_object);
214 }
215 sub DescribeEventCategories {
216 my $self = shift;
217 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeEventCategories', @_);
218 return $self->caller->do_call($self, $call_object);
219 }
220 sub DescribeEvents {
221 my $self = shift;
222 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeEvents', @_);
223 return $self->caller->do_call($self, $call_object);
224 }
225 sub DescribeEventSubscriptions {
226 my $self = shift;
227 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeEventSubscriptions', @_);
228 return $self->caller->do_call($self, $call_object);
229 }
230 sub DescribeOrderableDBInstanceOptions {
231 my $self = shift;
232 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeOrderableDBInstanceOptions', @_);
233 return $self->caller->do_call($self, $call_object);
234 }
235 sub DescribePendingMaintenanceActions {
236 my $self = shift;
237 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribePendingMaintenanceActions', @_);
238 return $self->caller->do_call($self, $call_object);
239 }
240 sub DescribeValidDBInstanceModifications {
241 my $self = shift;
242 my $call_object = $self->new_with_coercions('Paws::Neptune::DescribeValidDBInstanceModifications', @_);
243 return $self->caller->do_call($self, $call_object);
244 }
245 sub FailoverDBCluster {
246 my $self = shift;
247 my $call_object = $self->new_with_coercions('Paws::Neptune::FailoverDBCluster', @_);
248 return $self->caller->do_call($self, $call_object);
249 }
250 sub ListTagsForResource {
251 my $self = shift;
252 my $call_object = $self->new_with_coercions('Paws::Neptune::ListTagsForResource', @_);
253 return $self->caller->do_call($self, $call_object);
254 }
255 sub ModifyDBCluster {
256 my $self = shift;
257 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyDBCluster', @_);
258 return $self->caller->do_call($self, $call_object);
259 }
260 sub ModifyDBClusterEndpoint {
261 my $self = shift;
262 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyDBClusterEndpoint', @_);
263 return $self->caller->do_call($self, $call_object);
264 }
265 sub ModifyDBClusterParameterGroup {
266 my $self = shift;
267 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyDBClusterParameterGroup', @_);
268 return $self->caller->do_call($self, $call_object);
269 }
270 sub ModifyDBClusterSnapshotAttribute {
271 my $self = shift;
272 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyDBClusterSnapshotAttribute', @_);
273 return $self->caller->do_call($self, $call_object);
274 }
275 sub ModifyDBInstance {
276 my $self = shift;
277 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyDBInstance', @_);
278 return $self->caller->do_call($self, $call_object);
279 }
280 sub ModifyDBParameterGroup {
281 my $self = shift;
282 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyDBParameterGroup', @_);
283 return $self->caller->do_call($self, $call_object);
284 }
285 sub ModifyDBSubnetGroup {
286 my $self = shift;
287 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyDBSubnetGroup', @_);
288 return $self->caller->do_call($self, $call_object);
289 }
290 sub ModifyEventSubscription {
291 my $self = shift;
292 my $call_object = $self->new_with_coercions('Paws::Neptune::ModifyEventSubscription', @_);
293 return $self->caller->do_call($self, $call_object);
294 }
295 sub PromoteReadReplicaDBCluster {
296 my $self = shift;
297 my $call_object = $self->new_with_coercions('Paws::Neptune::PromoteReadReplicaDBCluster', @_);
298 return $self->caller->do_call($self, $call_object);
299 }
300 sub RebootDBInstance {
301 my $self = shift;
302 my $call_object = $self->new_with_coercions('Paws::Neptune::RebootDBInstance', @_);
303 return $self->caller->do_call($self, $call_object);
304 }
305 sub RemoveRoleFromDBCluster {
306 my $self = shift;
307 my $call_object = $self->new_with_coercions('Paws::Neptune::RemoveRoleFromDBCluster', @_);
308 return $self->caller->do_call($self, $call_object);
309 }
310 sub RemoveSourceIdentifierFromSubscription {
311 my $self = shift;
312 my $call_object = $self->new_with_coercions('Paws::Neptune::RemoveSourceIdentifierFromSubscription', @_);
313 return $self->caller->do_call($self, $call_object);
314 }
315 sub RemoveTagsFromResource {
316 my $self = shift;
317 my $call_object = $self->new_with_coercions('Paws::Neptune::RemoveTagsFromResource', @_);
318 return $self->caller->do_call($self, $call_object);
319 }
320 sub ResetDBClusterParameterGroup {
321 my $self = shift;
322 my $call_object = $self->new_with_coercions('Paws::Neptune::ResetDBClusterParameterGroup', @_);
323 return $self->caller->do_call($self, $call_object);
324 }
325 sub ResetDBParameterGroup {
326 my $self = shift;
327 my $call_object = $self->new_with_coercions('Paws::Neptune::ResetDBParameterGroup', @_);
328 return $self->caller->do_call($self, $call_object);
329 }
330 sub RestoreDBClusterFromSnapshot {
331 my $self = shift;
332 my $call_object = $self->new_with_coercions('Paws::Neptune::RestoreDBClusterFromSnapshot', @_);
333 return $self->caller->do_call($self, $call_object);
334 }
335 sub RestoreDBClusterToPointInTime {
336 my $self = shift;
337 my $call_object = $self->new_with_coercions('Paws::Neptune::RestoreDBClusterToPointInTime', @_);
338 return $self->caller->do_call($self, $call_object);
339 }
340 sub StartDBCluster {
341 my $self = shift;
342 my $call_object = $self->new_with_coercions('Paws::Neptune::StartDBCluster', @_);
343 return $self->caller->do_call($self, $call_object);
344 }
345 sub StopDBCluster {
346 my $self = shift;
347 my $call_object = $self->new_with_coercions('Paws::Neptune::StopDBCluster', @_);
348 return $self->caller->do_call($self, $call_object);
349 }
350
351 sub DescribeAllDBClusterEndpoints {
352 my $self = shift;
353  
354 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
355 my $result = $self->DescribeDBClusterEndpoints(@_);
356 my $next_result = $result;
357  
358 if (not defined $callback) {
359 while ($next_result->Marker) {
360 $next_result = $self->DescribeDBClusterEndpoints(@_, Marker => $next_result->Marker);
361 push @{ $result->DBClusterEndpoints }, @{ $next_result->DBClusterEndpoints };
362 }
363 return $result;
364 } else {
365 while ($result->Marker) {
366 $callback->($_ => 'DBClusterEndpoints') foreach (@{ $result->DBClusterEndpoints });
367 $result = $self->DescribeDBClusterEndpoints(@_, Marker => $result->Marker);
368 }
369 $callback->($_ => 'DBClusterEndpoints') foreach (@{ $result->DBClusterEndpoints });
370 }
371  
372 return undef
373 }
374 sub DescribeAllDBClusterParameterGroups {
375 my $self = shift;
376  
377 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
378 my $result = $self->DescribeDBClusterParameterGroups(@_);
379 my $next_result = $result;
380  
381 if (not defined $callback) {
382 while ($next_result->Marker) {
383 $next_result = $self->DescribeDBClusterParameterGroups(@_, Marker => $next_result->Marker);
384 push @{ $result->DBClusterParameterGroups }, @{ $next_result->DBClusterParameterGroups };
385 }
386 return $result;
387 } else {
388 while ($result->Marker) {
389 $callback->($_ => 'DBClusterParameterGroups') foreach (@{ $result->DBClusterParameterGroups });
390 $result = $self->DescribeDBClusterParameterGroups(@_, Marker => $result->Marker);
391 }
392 $callback->($_ => 'DBClusterParameterGroups') foreach (@{ $result->DBClusterParameterGroups });
393 }
394  
395 return undef
396 }
397 sub DescribeAllDBClusterParameters {
398 my $self = shift;
399  
400 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
401 my $result = $self->DescribeDBClusterParameters(@_);
402 my $next_result = $result;
403  
404 if (not defined $callback) {
405 while ($next_result->Marker) {
406 $next_result = $self->DescribeDBClusterParameters(@_, Marker => $next_result->Marker);
407 push @{ $result->Parameters }, @{ $next_result->Parameters };
408 }
409 return $result;
410 } else {
411 while ($result->Marker) {
412 $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
413 $result = $self->DescribeDBClusterParameters(@_, Marker => $result->Marker);
414 }
415 $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
416 }
417  
418 return undef
419 }
420 sub DescribeAllDBClusters {
421 my $self = shift;
422  
423 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
424 my $result = $self->DescribeDBClusters(@_);
425 my $next_result = $result;
426  
427 if (not defined $callback) {
428 while ($next_result->Marker) {
429 $next_result = $self->DescribeDBClusters(@_, Marker => $next_result->Marker);
430 push @{ $result->DBClusters }, @{ $next_result->DBClusters };
431 }
432 return $result;
433 } else {
434 while ($result->Marker) {
435 $callback->($_ => 'DBClusters') foreach (@{ $result->DBClusters });
436 $result = $self->DescribeDBClusters(@_, Marker => $result->Marker);
437 }
438 $callback->($_ => 'DBClusters') foreach (@{ $result->DBClusters });
439 }
440  
441 return undef
442 }
443 sub DescribeAllDBClusterSnapshots {
444 my $self = shift;
445  
446 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
447 my $result = $self->DescribeDBClusterSnapshots(@_);
448 my $next_result = $result;
449  
450 if (not defined $callback) {
451 while ($next_result->Marker) {
452 $next_result = $self->DescribeDBClusterSnapshots(@_, Marker => $next_result->Marker);
453 push @{ $result->DBClusterSnapshots }, @{ $next_result->DBClusterSnapshots };
454 }
455 return $result;
456 } else {
457 while ($result->Marker) {
458 $callback->($_ => 'DBClusterSnapshots') foreach (@{ $result->DBClusterSnapshots });
459 $result = $self->DescribeDBClusterSnapshots(@_, Marker => $result->Marker);
460 }
461 $callback->($_ => 'DBClusterSnapshots') foreach (@{ $result->DBClusterSnapshots });
462 }
463  
464 return undef
465 }
466 sub DescribeAllDBEngineVersions {
467 my $self = shift;
468  
469 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
470 my $result = $self->DescribeDBEngineVersions(@_);
471 my $next_result = $result;
472  
473 if (not defined $callback) {
474 while ($next_result->Marker) {
475 $next_result = $self->DescribeDBEngineVersions(@_, Marker => $next_result->Marker);
476 push @{ $result->DBEngineVersions }, @{ $next_result->DBEngineVersions };
477 }
478 return $result;
479 } else {
480 while ($result->Marker) {
481 $callback->($_ => 'DBEngineVersions') foreach (@{ $result->DBEngineVersions });
482 $result = $self->DescribeDBEngineVersions(@_, Marker => $result->Marker);
483 }
484 $callback->($_ => 'DBEngineVersions') foreach (@{ $result->DBEngineVersions });
485 }
486  
487 return undef
488 }
489 sub DescribeAllDBInstances {
490 my $self = shift;
491  
492 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
493 my $result = $self->DescribeDBInstances(@_);
494 my $next_result = $result;
495  
496 if (not defined $callback) {
497 while ($next_result->Marker) {
498 $next_result = $self->DescribeDBInstances(@_, Marker => $next_result->Marker);
499 push @{ $result->DBInstances }, @{ $next_result->DBInstances };
500 }
501 return $result;
502 } else {
503 while ($result->Marker) {
504 $callback->($_ => 'DBInstances') foreach (@{ $result->DBInstances });
505 $result = $self->DescribeDBInstances(@_, Marker => $result->Marker);
506 }
507 $callback->($_ => 'DBInstances') foreach (@{ $result->DBInstances });
508 }
509  
510 return undef
511 }
512 sub DescribeAllDBParameterGroups {
513 my $self = shift;
514  
515 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
516 my $result = $self->DescribeDBParameterGroups(@_);
517 my $next_result = $result;
518  
519 if (not defined $callback) {
520 while ($next_result->Marker) {
521 $next_result = $self->DescribeDBParameterGroups(@_, Marker => $next_result->Marker);
522 push @{ $result->DBParameterGroups }, @{ $next_result->DBParameterGroups };
523 }
524 return $result;
525 } else {
526 while ($result->Marker) {
527 $callback->($_ => 'DBParameterGroups') foreach (@{ $result->DBParameterGroups });
528 $result = $self->DescribeDBParameterGroups(@_, Marker => $result->Marker);
529 }
530 $callback->($_ => 'DBParameterGroups') foreach (@{ $result->DBParameterGroups });
531 }
532  
533 return undef
534 }
535 sub DescribeAllDBParameters {
536 my $self = shift;
537  
538 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
539 my $result = $self->DescribeDBParameters(@_);
540 my $next_result = $result;
541  
542 if (not defined $callback) {
543 while ($next_result->Marker) {
544 $next_result = $self->DescribeDBParameters(@_, Marker => $next_result->Marker);
545 push @{ $result->Parameters }, @{ $next_result->Parameters };
546 }
547 return $result;
548 } else {
549 while ($result->Marker) {
550 $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
551 $result = $self->DescribeDBParameters(@_, Marker => $result->Marker);
552 }
553 $callback->($_ => 'Parameters') foreach (@{ $result->Parameters });
554 }
555  
556 return undef
557 }
558 sub DescribeAllDBSubnetGroups {
559 my $self = shift;
560  
561 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
562 my $result = $self->DescribeDBSubnetGroups(@_);
563 my $next_result = $result;
564  
565 if (not defined $callback) {
566 while ($next_result->Marker) {
567 $next_result = $self->DescribeDBSubnetGroups(@_, Marker => $next_result->Marker);
568 push @{ $result->DBSubnetGroups }, @{ $next_result->DBSubnetGroups };
569 }
570 return $result;
571 } else {
572 while ($result->Marker) {
573 $callback->($_ => 'DBSubnetGroups') foreach (@{ $result->DBSubnetGroups });
574 $result = $self->DescribeDBSubnetGroups(@_, Marker => $result->Marker);
575 }
576 $callback->($_ => 'DBSubnetGroups') foreach (@{ $result->DBSubnetGroups });
577 }
578  
579 return undef
580 }
581 sub DescribeAllEngineDefaultParameters {
582 my $self = shift;
583  
584 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
585 my $result = $self->DescribeEngineDefaultParameters(@_);
586 my $next_result = $result;
587  
588 if (not defined $callback) {
589 while ($next_result->EngineDefaults->Marker) {
590 $next_result = $self->DescribeEngineDefaultParameters(@_, Marker => $next_result->EngineDefaults->Marker);
591 push @{ $result->EngineDefaults->Parameters }, @{ $next_result->EngineDefaults->Parameters };
592 }
593 return $result;
594 } else {
595 while ($result->EngineDefaults->Marker) {
596 $callback->($_ => 'EngineDefaults.Parameters') foreach (@{ $result->EngineDefaults->Parameters });
597 $result = $self->DescribeEngineDefaultParameters(@_, Marker => $result->EngineDefaults->Marker);
598 }
599 $callback->($_ => 'EngineDefaults.Parameters') foreach (@{ $result->EngineDefaults->Parameters });
600 }
601  
602 return undef
603 }
604 sub DescribeAllEvents {
605 my $self = shift;
606  
607 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
608 my $result = $self->DescribeEvents(@_);
609 my $next_result = $result;
610  
611 if (not defined $callback) {
612 while ($next_result->Marker) {
613 $next_result = $self->DescribeEvents(@_, Marker => $next_result->Marker);
614 push @{ $result->Events }, @{ $next_result->Events };
615 }
616 return $result;
617 } else {
618 while ($result->Marker) {
619 $callback->($_ => 'Events') foreach (@{ $result->Events });
620 $result = $self->DescribeEvents(@_, Marker => $result->Marker);
621 }
622 $callback->($_ => 'Events') foreach (@{ $result->Events });
623 }
624  
625 return undef
626 }
627 sub DescribeAllEventSubscriptions {
628 my $self = shift;
629  
630 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
631 my $result = $self->DescribeEventSubscriptions(@_);
632 my $next_result = $result;
633  
634 if (not defined $callback) {
635 while ($next_result->Marker) {
636 $next_result = $self->DescribeEventSubscriptions(@_, Marker => $next_result->Marker);
637 push @{ $result->EventSubscriptionsList }, @{ $next_result->EventSubscriptionsList };
638 }
639 return $result;
640 } else {
641 while ($result->Marker) {
642 $callback->($_ => 'EventSubscriptionsList') foreach (@{ $result->EventSubscriptionsList });
643 $result = $self->DescribeEventSubscriptions(@_, Marker => $result->Marker);
644 }
645 $callback->($_ => 'EventSubscriptionsList') foreach (@{ $result->EventSubscriptionsList });
646 }
647  
648 return undef
649 }
650 sub DescribeAllOrderableDBInstanceOptions {
651 my $self = shift;
652  
653 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
654 my $result = $self->DescribeOrderableDBInstanceOptions(@_);
655 my $next_result = $result;
656  
657 if (not defined $callback) {
658 while ($next_result->Marker) {
659 $next_result = $self->DescribeOrderableDBInstanceOptions(@_, Marker => $next_result->Marker);
660 push @{ $result->OrderableDBInstanceOptions }, @{ $next_result->OrderableDBInstanceOptions };
661 }
662 return $result;
663 } else {
664 while ($result->Marker) {
665 $callback->($_ => 'OrderableDBInstanceOptions') foreach (@{ $result->OrderableDBInstanceOptions });
666 $result = $self->DescribeOrderableDBInstanceOptions(@_, Marker => $result->Marker);
667 }
668 $callback->($_ => 'OrderableDBInstanceOptions') foreach (@{ $result->OrderableDBInstanceOptions });
669 }
670  
671 return undef
672 }
673 sub DescribeAllPendingMaintenanceActions {
674 my $self = shift;
675  
676 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
677 my $result = $self->DescribePendingMaintenanceActions(@_);
678 my $next_result = $result;
679  
680 if (not defined $callback) {
681 while ($next_result->Marker) {
682 $next_result = $self->DescribePendingMaintenanceActions(@_, Marker => $next_result->Marker);
683 push @{ $result->PendingMaintenanceActions }, @{ $next_result->PendingMaintenanceActions };
684 }
685 return $result;
686 } else {
687 while ($result->Marker) {
688 $callback->($_ => 'PendingMaintenanceActions') foreach (@{ $result->PendingMaintenanceActions });
689 $result = $self->DescribePendingMaintenanceActions(@_, Marker => $result->Marker);
690 }
691 $callback->($_ => 'PendingMaintenanceActions') foreach (@{ $result->PendingMaintenanceActions });
692 }
693  
694 return undef
695 }
696  
697  
698 sub operations { qw/AddRoleToDBCluster AddSourceIdentifierToSubscription AddTagsToResource ApplyPendingMaintenanceAction CopyDBClusterParameterGroup CopyDBClusterSnapshot CopyDBParameterGroup CreateDBCluster CreateDBClusterEndpoint CreateDBClusterParameterGroup CreateDBClusterSnapshot CreateDBInstance CreateDBParameterGroup CreateDBSubnetGroup CreateEventSubscription DeleteDBCluster DeleteDBClusterEndpoint DeleteDBClusterParameterGroup DeleteDBClusterSnapshot DeleteDBInstance DeleteDBParameterGroup DeleteDBSubnetGroup DeleteEventSubscription DescribeDBClusterEndpoints DescribeDBClusterParameterGroups DescribeDBClusterParameters DescribeDBClusters DescribeDBClusterSnapshotAttributes DescribeDBClusterSnapshots DescribeDBEngineVersions DescribeDBInstances DescribeDBParameterGroups DescribeDBParameters DescribeDBSubnetGroups DescribeEngineDefaultClusterParameters DescribeEngineDefaultParameters DescribeEventCategories DescribeEvents DescribeEventSubscriptions DescribeOrderableDBInstanceOptions DescribePendingMaintenanceActions DescribeValidDBInstanceModifications FailoverDBCluster ListTagsForResource ModifyDBCluster ModifyDBClusterEndpoint ModifyDBClusterParameterGroup ModifyDBClusterSnapshotAttribute ModifyDBInstance ModifyDBParameterGroup ModifyDBSubnetGroup ModifyEventSubscription PromoteReadReplicaDBCluster RebootDBInstance RemoveRoleFromDBCluster RemoveSourceIdentifierFromSubscription RemoveTagsFromResource ResetDBClusterParameterGroup ResetDBParameterGroup RestoreDBClusterFromSnapshot RestoreDBClusterToPointInTime StartDBCluster StopDBCluster / }
699  
700 1;
701  
702 ### main pod documentation begin ###
703  
704 =head1 NAME
705  
706 Paws::Neptune - Perl Interface to AWS Amazon Neptune
707  
708 =head1 SYNOPSIS
709  
710 use Paws;
711  
712 my $obj = Paws->service('Neptune');
713 my $res = $obj->Method(
714 Arg1 => $val1,
715 Arg2 => [ 'V1', 'V2' ],
716 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
717 # of the arguments type
718 Arg3 => { Att1 => 'Val1' },
719 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
720 # the constructor of the arguments type
721 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
722 );
723  
724 =head1 DESCRIPTION
725  
726 Amazon Neptune
727  
728 Amazon Neptune is a fast, reliable, fully-managed graph database
729 service that makes it easy to build and run applications that work with
730 highly connected datasets. The core of Amazon Neptune is a
731 purpose-built, high-performance graph database engine optimized for
732 storing billions of relationships and querying the graph with
733 milliseconds latency. Amazon Neptune supports popular graph models
734 Property Graph and W3C's RDF, and their respective query languages
735 Apache TinkerPop Gremlin and SPARQL, allowing you to easily build
736 queries that efficiently navigate highly connected datasets. Neptune
737 powers graph use cases such as recommendation engines, fraud detection,
738 knowledge graphs, drug discovery, and network security.
739  
740 This interface reference for Amazon Neptune contains documentation for
741 a programming or command line interface you can use to manage Amazon
742 Neptune. Note that Amazon Neptune is asynchronous, which means that
743 some interfaces might require techniques such as polling or callback
744 functions to determine when a command has been applied. In this
745 reference, the parameter descriptions indicate whether a command is
746 applied immediately, on the next instance reboot, or during the
747 maintenance window. The reference structure is as follows, and we list
748 following some related topics from the user guide.
749  
750 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/rds-2014-10-31>
751  
752  
753 =head1 METHODS
754  
755 =head2 AddRoleToDBCluster
756  
757 =over
758  
759 =item DBClusterIdentifier => Str
760  
761 =item RoleArn => Str
762  
763 =item [FeatureName => Str]
764  
765  
766 =back
767  
768 Each argument is described in detail in: L<Paws::Neptune::AddRoleToDBCluster>
769  
770 Returns: nothing
771  
772 Associates an Identity and Access Management (IAM) role from an Neptune
773 DB cluster.
774  
775  
776 =head2 AddSourceIdentifierToSubscription
777  
778 =over
779  
780 =item SourceIdentifier => Str
781  
782 =item SubscriptionName => Str
783  
784  
785 =back
786  
787 Each argument is described in detail in: L<Paws::Neptune::AddSourceIdentifierToSubscription>
788  
789 Returns: a L<Paws::Neptune::AddSourceIdentifierToSubscriptionResult> instance
790  
791 Adds a source identifier to an existing event notification
792 subscription.
793  
794  
795 =head2 AddTagsToResource
796  
797 =over
798  
799 =item ResourceName => Str
800  
801 =item Tags => ArrayRef[L<Paws::Neptune::Tag>]
802  
803  
804 =back
805  
806 Each argument is described in detail in: L<Paws::Neptune::AddTagsToResource>
807  
808 Returns: nothing
809  
810 Adds metadata tags to an Amazon Neptune resource. These tags can also
811 be used with cost allocation reporting to track cost associated with
812 Amazon Neptune resources, or used in a Condition statement in an IAM
813 policy for Amazon Neptune.
814  
815  
816 =head2 ApplyPendingMaintenanceAction
817  
818 =over
819  
820 =item ApplyAction => Str
821  
822 =item OptInType => Str
823  
824 =item ResourceIdentifier => Str
825  
826  
827 =back
828  
829 Each argument is described in detail in: L<Paws::Neptune::ApplyPendingMaintenanceAction>
830  
831 Returns: a L<Paws::Neptune::ApplyPendingMaintenanceActionResult> instance
832  
833 Applies a pending maintenance action to a resource (for example, to a
834 DB instance).
835  
836  
837 =head2 CopyDBClusterParameterGroup
838  
839 =over
840  
841 =item SourceDBClusterParameterGroupIdentifier => Str
842  
843 =item TargetDBClusterParameterGroupDescription => Str
844  
845 =item TargetDBClusterParameterGroupIdentifier => Str
846  
847 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
848  
849  
850 =back
851  
852 Each argument is described in detail in: L<Paws::Neptune::CopyDBClusterParameterGroup>
853  
854 Returns: a L<Paws::Neptune::CopyDBClusterParameterGroupResult> instance
855  
856 Copies the specified DB cluster parameter group.
857  
858  
859 =head2 CopyDBClusterSnapshot
860  
861 =over
862  
863 =item SourceDBClusterSnapshotIdentifier => Str
864  
865 =item TargetDBClusterSnapshotIdentifier => Str
866  
867 =item [CopyTags => Bool]
868  
869 =item [KmsKeyId => Str]
870  
871 =item [PreSignedUrl => Str]
872  
873 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
874  
875  
876 =back
877  
878 Each argument is described in detail in: L<Paws::Neptune::CopyDBClusterSnapshot>
879  
880 Returns: a L<Paws::Neptune::CopyDBClusterSnapshotResult> instance
881  
882 Copies a snapshot of a DB cluster.
883  
884 To copy a DB cluster snapshot from a shared manual DB cluster snapshot,
885 C<SourceDBClusterSnapshotIdentifier> must be the Amazon Resource Name
886 (ARN) of the shared DB cluster snapshot.
887  
888  
889 =head2 CopyDBParameterGroup
890  
891 =over
892  
893 =item SourceDBParameterGroupIdentifier => Str
894  
895 =item TargetDBParameterGroupDescription => Str
896  
897 =item TargetDBParameterGroupIdentifier => Str
898  
899 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
900  
901  
902 =back
903  
904 Each argument is described in detail in: L<Paws::Neptune::CopyDBParameterGroup>
905  
906 Returns: a L<Paws::Neptune::CopyDBParameterGroupResult> instance
907  
908 Copies the specified DB parameter group.
909  
910  
911 =head2 CreateDBCluster
912  
913 =over
914  
915 =item DBClusterIdentifier => Str
916  
917 =item Engine => Str
918  
919 =item [AvailabilityZones => ArrayRef[Str|Undef]]
920  
921 =item [BackupRetentionPeriod => Int]
922  
923 =item [CharacterSetName => Str]
924  
925 =item [CopyTagsToSnapshot => Bool]
926  
927 =item [DatabaseName => Str]
928  
929 =item [DBClusterParameterGroupName => Str]
930  
931 =item [DBSubnetGroupName => Str]
932  
933 =item [DeletionProtection => Bool]
934  
935 =item [EnableCloudwatchLogsExports => ArrayRef[Str|Undef]]
936  
937 =item [EnableIAMDatabaseAuthentication => Bool]
938  
939 =item [EngineVersion => Str]
940  
941 =item [KmsKeyId => Str]
942  
943 =item [MasterUsername => Str]
944  
945 =item [MasterUserPassword => Str]
946  
947 =item [OptionGroupName => Str]
948  
949 =item [Port => Int]
950  
951 =item [PreferredBackupWindow => Str]
952  
953 =item [PreferredMaintenanceWindow => Str]
954  
955 =item [PreSignedUrl => Str]
956  
957 =item [ReplicationSourceIdentifier => Str]
958  
959 =item [StorageEncrypted => Bool]
960  
961 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
962  
963 =item [VpcSecurityGroupIds => ArrayRef[Str|Undef]]
964  
965  
966 =back
967  
968 Each argument is described in detail in: L<Paws::Neptune::CreateDBCluster>
969  
970 Returns: a L<Paws::Neptune::CreateDBClusterResult> instance
971  
972 Creates a new Amazon Neptune DB cluster.
973  
974 You can use the C<ReplicationSourceIdentifier> parameter to create the
975 DB cluster as a Read Replica of another DB cluster or Amazon Neptune DB
976 instance.
977  
978 Note that when you create a new cluster using C<CreateDBCluster>
979 directly, deletion protection is disabled by default (when you create a
980 new production cluster in the console, deletion protection is enabled
981 by default). You can only delete a DB cluster if its
982 C<DeletionProtection> field is set to C<false>.
983  
984  
985 =head2 CreateDBClusterEndpoint
986  
987 =over
988  
989 =item DBClusterEndpointIdentifier => Str
990  
991 =item DBClusterIdentifier => Str
992  
993 =item EndpointType => Str
994  
995 =item [ExcludedMembers => ArrayRef[Str|Undef]]
996  
997 =item [StaticMembers => ArrayRef[Str|Undef]]
998  
999 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
1000  
1001  
1002 =back
1003  
1004 Each argument is described in detail in: L<Paws::Neptune::CreateDBClusterEndpoint>
1005  
1006 Returns: a L<Paws::Neptune::CreateDBClusterEndpointOutput> instance
1007  
1008 Creates a new custom endpoint and associates it with an Amazon Neptune
1009 DB cluster.
1010  
1011  
1012 =head2 CreateDBClusterParameterGroup
1013  
1014 =over
1015  
1016 =item DBClusterParameterGroupName => Str
1017  
1018 =item DBParameterGroupFamily => Str
1019  
1020 =item Description => Str
1021  
1022 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
1023  
1024  
1025 =back
1026  
1027 Each argument is described in detail in: L<Paws::Neptune::CreateDBClusterParameterGroup>
1028  
1029 Returns: a L<Paws::Neptune::CreateDBClusterParameterGroupResult> instance
1030  
1031 Creates a new DB cluster parameter group.
1032  
1033 Parameters in a DB cluster parameter group apply to all of the
1034 instances in a DB cluster.
1035  
1036 A DB cluster parameter group is initially created with the default
1037 parameters for the database engine used by instances in the DB cluster.
1038 To provide custom values for any of the parameters, you must modify the
1039 group after creating it using ModifyDBClusterParameterGroup. Once
1040 you've created a DB cluster parameter group, you need to associate it
1041 with your DB cluster using ModifyDBCluster. When you associate a new DB
1042 cluster parameter group with a running DB cluster, you need to reboot
1043 the DB instances in the DB cluster without failover for the new DB
1044 cluster parameter group and associated settings to take effect.
1045  
1046 After you create a DB cluster parameter group, you should wait at least
1047 5 minutes before creating your first DB cluster that uses that DB
1048 cluster parameter group as the default parameter group. This allows
1049 Amazon Neptune to fully complete the create action before the DB
1050 cluster parameter group is used as the default for a new DB cluster.
1051 This is especially important for parameters that are critical when
1052 creating the default database for a DB cluster, such as the character
1053 set for the default database defined by the C<character_set_database>
1054 parameter. You can use the I<Parameter Groups> option of the Amazon
1055 Neptune console (https://console.aws.amazon.com/rds/) or the
1056 DescribeDBClusterParameters command to verify that your DB cluster
1057 parameter group has been created or modified.
1058  
1059  
1060 =head2 CreateDBClusterSnapshot
1061  
1062 =over
1063  
1064 =item DBClusterIdentifier => Str
1065  
1066 =item DBClusterSnapshotIdentifier => Str
1067  
1068 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
1069  
1070  
1071 =back
1072  
1073 Each argument is described in detail in: L<Paws::Neptune::CreateDBClusterSnapshot>
1074  
1075 Returns: a L<Paws::Neptune::CreateDBClusterSnapshotResult> instance
1076  
1077 Creates a snapshot of a DB cluster.
1078  
1079  
1080 =head2 CreateDBInstance
1081  
1082 =over
1083  
1084 =item DBInstanceClass => Str
1085  
1086 =item DBInstanceIdentifier => Str
1087  
1088 =item Engine => Str
1089  
1090 =item [AllocatedStorage => Int]
1091  
1092 =item [AutoMinorVersionUpgrade => Bool]
1093  
1094 =item [AvailabilityZone => Str]
1095  
1096 =item [BackupRetentionPeriod => Int]
1097  
1098 =item [CharacterSetName => Str]
1099  
1100 =item [CopyTagsToSnapshot => Bool]
1101  
1102 =item [DBClusterIdentifier => Str]
1103  
1104 =item [DBName => Str]
1105  
1106 =item [DBParameterGroupName => Str]
1107  
1108 =item [DBSecurityGroups => ArrayRef[Str|Undef]]
1109  
1110 =item [DBSubnetGroupName => Str]
1111  
1112 =item [DeletionProtection => Bool]
1113  
1114 =item [Domain => Str]
1115  
1116 =item [DomainIAMRoleName => Str]
1117  
1118 =item [EnableCloudwatchLogsExports => ArrayRef[Str|Undef]]
1119  
1120 =item [EnableIAMDatabaseAuthentication => Bool]
1121  
1122 =item [EnablePerformanceInsights => Bool]
1123  
1124 =item [EngineVersion => Str]
1125  
1126 =item [Iops => Int]
1127  
1128 =item [KmsKeyId => Str]
1129  
1130 =item [LicenseModel => Str]
1131  
1132 =item [MasterUsername => Str]
1133  
1134 =item [MasterUserPassword => Str]
1135  
1136 =item [MonitoringInterval => Int]
1137  
1138 =item [MonitoringRoleArn => Str]
1139  
1140 =item [MultiAZ => Bool]
1141  
1142 =item [OptionGroupName => Str]
1143  
1144 =item [PerformanceInsightsKMSKeyId => Str]
1145  
1146 =item [Port => Int]
1147  
1148 =item [PreferredBackupWindow => Str]
1149  
1150 =item [PreferredMaintenanceWindow => Str]
1151  
1152 =item [PromotionTier => Int]
1153  
1154 =item [PubliclyAccessible => Bool]
1155  
1156 =item [StorageEncrypted => Bool]
1157  
1158 =item [StorageType => Str]
1159  
1160 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
1161  
1162 =item [TdeCredentialArn => Str]
1163  
1164 =item [TdeCredentialPassword => Str]
1165  
1166 =item [Timezone => Str]
1167  
1168 =item [VpcSecurityGroupIds => ArrayRef[Str|Undef]]
1169  
1170  
1171 =back
1172  
1173 Each argument is described in detail in: L<Paws::Neptune::CreateDBInstance>
1174  
1175 Returns: a L<Paws::Neptune::CreateDBInstanceResult> instance
1176  
1177 Creates a new DB instance.
1178  
1179  
1180 =head2 CreateDBParameterGroup
1181  
1182 =over
1183  
1184 =item DBParameterGroupFamily => Str
1185  
1186 =item DBParameterGroupName => Str
1187  
1188 =item Description => Str
1189  
1190 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
1191  
1192  
1193 =back
1194  
1195 Each argument is described in detail in: L<Paws::Neptune::CreateDBParameterGroup>
1196  
1197 Returns: a L<Paws::Neptune::CreateDBParameterGroupResult> instance
1198  
1199 Creates a new DB parameter group.
1200  
1201 A DB parameter group is initially created with the default parameters
1202 for the database engine used by the DB instance. To provide custom
1203 values for any of the parameters, you must modify the group after
1204 creating it using I<ModifyDBParameterGroup>. Once you've created a DB
1205 parameter group, you need to associate it with your DB instance using
1206 I<ModifyDBInstance>. When you associate a new DB parameter group with a
1207 running DB instance, you need to reboot the DB instance without
1208 failover for the new DB parameter group and associated settings to take
1209 effect.
1210  
1211 After you create a DB parameter group, you should wait at least 5
1212 minutes before creating your first DB instance that uses that DB
1213 parameter group as the default parameter group. This allows Amazon
1214 Neptune to fully complete the create action before the parameter group
1215 is used as the default for a new DB instance. This is especially
1216 important for parameters that are critical when creating the default
1217 database for a DB instance, such as the character set for the default
1218 database defined by the C<character_set_database> parameter. You can
1219 use the I<Parameter Groups> option of the Amazon Neptune console or the
1220 I<DescribeDBParameters> command to verify that your DB parameter group
1221 has been created or modified.
1222  
1223  
1224 =head2 CreateDBSubnetGroup
1225  
1226 =over
1227  
1228 =item DBSubnetGroupDescription => Str
1229  
1230 =item DBSubnetGroupName => Str
1231  
1232 =item SubnetIds => ArrayRef[Str|Undef]
1233  
1234 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
1235  
1236  
1237 =back
1238  
1239 Each argument is described in detail in: L<Paws::Neptune::CreateDBSubnetGroup>
1240  
1241 Returns: a L<Paws::Neptune::CreateDBSubnetGroupResult> instance
1242  
1243 Creates a new DB subnet group. DB subnet groups must contain at least
1244 one subnet in at least two AZs in the Amazon Region.
1245  
1246  
1247 =head2 CreateEventSubscription
1248  
1249 =over
1250  
1251 =item SnsTopicArn => Str
1252  
1253 =item SubscriptionName => Str
1254  
1255 =item [Enabled => Bool]
1256  
1257 =item [EventCategories => ArrayRef[Str|Undef]]
1258  
1259 =item [SourceIds => ArrayRef[Str|Undef]]
1260  
1261 =item [SourceType => Str]
1262  
1263 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
1264  
1265  
1266 =back
1267  
1268 Each argument is described in detail in: L<Paws::Neptune::CreateEventSubscription>
1269  
1270 Returns: a L<Paws::Neptune::CreateEventSubscriptionResult> instance
1271  
1272 Creates an event notification subscription. This action requires a
1273 topic ARN (Amazon Resource Name) created by either the Neptune console,
1274 the SNS console, or the SNS API. To obtain an ARN with SNS, you must
1275 create a topic in Amazon SNS and subscribe to the topic. The ARN is
1276 displayed in the SNS console.
1277  
1278 You can specify the type of source (SourceType) you want to be notified
1279 of, provide a list of Neptune sources (SourceIds) that triggers the
1280 events, and provide a list of event categories (EventCategories) for
1281 events you want to be notified of. For example, you can specify
1282 SourceType = db-instance, SourceIds = mydbinstance1, mydbinstance2 and
1283 EventCategories = Availability, Backup.
1284  
1285 If you specify both the SourceType and SourceIds, such as SourceType =
1286 db-instance and SourceIdentifier = myDBInstance1, you are notified of
1287 all the db-instance events for the specified source. If you specify a
1288 SourceType but do not specify a SourceIdentifier, you receive notice of
1289 the events for that source type for all your Neptune sources. If you do
1290 not specify either the SourceType nor the SourceIdentifier, you are
1291 notified of events generated from all Neptune sources belonging to your
1292 customer account.
1293  
1294  
1295 =head2 DeleteDBCluster
1296  
1297 =over
1298  
1299 =item DBClusterIdentifier => Str
1300  
1301 =item [FinalDBSnapshotIdentifier => Str]
1302  
1303 =item [SkipFinalSnapshot => Bool]
1304  
1305  
1306 =back
1307  
1308 Each argument is described in detail in: L<Paws::Neptune::DeleteDBCluster>
1309  
1310 Returns: a L<Paws::Neptune::DeleteDBClusterResult> instance
1311  
1312 The DeleteDBCluster action deletes a previously provisioned DB cluster.
1313 When you delete a DB cluster, all automated backups for that DB cluster
1314 are deleted and can't be recovered. Manual DB cluster snapshots of the
1315 specified DB cluster are not deleted.
1316  
1317 Note that the DB Cluster cannot be deleted if deletion protection is
1318 enabled. To delete it, you must first set its C<DeletionProtection>
1319 field to C<False>.
1320  
1321  
1322 =head2 DeleteDBClusterEndpoint
1323  
1324 =over
1325  
1326 =item DBClusterEndpointIdentifier => Str
1327  
1328  
1329 =back
1330  
1331 Each argument is described in detail in: L<Paws::Neptune::DeleteDBClusterEndpoint>
1332  
1333 Returns: a L<Paws::Neptune::DeleteDBClusterEndpointOutput> instance
1334  
1335 Deletes a custom endpoint and removes it from an Amazon Neptune DB
1336 cluster.
1337  
1338  
1339 =head2 DeleteDBClusterParameterGroup
1340  
1341 =over
1342  
1343 =item DBClusterParameterGroupName => Str
1344  
1345  
1346 =back
1347  
1348 Each argument is described in detail in: L<Paws::Neptune::DeleteDBClusterParameterGroup>
1349  
1350 Returns: nothing
1351  
1352 Deletes a specified DB cluster parameter group. The DB cluster
1353 parameter group to be deleted can't be associated with any DB clusters.
1354  
1355  
1356 =head2 DeleteDBClusterSnapshot
1357  
1358 =over
1359  
1360 =item DBClusterSnapshotIdentifier => Str
1361  
1362  
1363 =back
1364  
1365 Each argument is described in detail in: L<Paws::Neptune::DeleteDBClusterSnapshot>
1366  
1367 Returns: a L<Paws::Neptune::DeleteDBClusterSnapshotResult> instance
1368  
1369 Deletes a DB cluster snapshot. If the snapshot is being copied, the
1370 copy operation is terminated.
1371  
1372 The DB cluster snapshot must be in the C<available> state to be
1373 deleted.
1374  
1375  
1376 =head2 DeleteDBInstance
1377  
1378 =over
1379  
1380 =item DBInstanceIdentifier => Str
1381  
1382 =item [FinalDBSnapshotIdentifier => Str]
1383  
1384 =item [SkipFinalSnapshot => Bool]
1385  
1386  
1387 =back
1388  
1389 Each argument is described in detail in: L<Paws::Neptune::DeleteDBInstance>
1390  
1391 Returns: a L<Paws::Neptune::DeleteDBInstanceResult> instance
1392  
1393 The DeleteDBInstance action deletes a previously provisioned DB
1394 instance. When you delete a DB instance, all automated backups for that
1395 instance are deleted and can't be recovered. Manual DB snapshots of the
1396 DB instance to be deleted by C<DeleteDBInstance> are not deleted.
1397  
1398 If you request a final DB snapshot the status of the Amazon Neptune DB
1399 instance is C<deleting> until the DB snapshot is created. The API
1400 action C<DescribeDBInstance> is used to monitor the status of this
1401 operation. The action can't be canceled or reverted once submitted.
1402  
1403 Note that when a DB instance is in a failure state and has a status of
1404 C<failed>, C<incompatible-restore>, or C<incompatible-network>, you can
1405 only delete it when the C<SkipFinalSnapshot> parameter is set to
1406 C<true>.
1407  
1408 You can't delete a DB instance if it is the only instance in the DB
1409 cluster, or if it has deletion protection enabled.
1410  
1411  
1412 =head2 DeleteDBParameterGroup
1413  
1414 =over
1415  
1416 =item DBParameterGroupName => Str
1417  
1418  
1419 =back
1420  
1421 Each argument is described in detail in: L<Paws::Neptune::DeleteDBParameterGroup>
1422  
1423 Returns: nothing
1424  
1425 Deletes a specified DBParameterGroup. The DBParameterGroup to be
1426 deleted can't be associated with any DB instances.
1427  
1428  
1429 =head2 DeleteDBSubnetGroup
1430  
1431 =over
1432  
1433 =item DBSubnetGroupName => Str
1434  
1435  
1436 =back
1437  
1438 Each argument is described in detail in: L<Paws::Neptune::DeleteDBSubnetGroup>
1439  
1440 Returns: nothing
1441  
1442 Deletes a DB subnet group.
1443  
1444 The specified database subnet group must not be associated with any DB
1445 instances.
1446  
1447  
1448 =head2 DeleteEventSubscription
1449  
1450 =over
1451  
1452 =item SubscriptionName => Str
1453  
1454  
1455 =back
1456  
1457 Each argument is described in detail in: L<Paws::Neptune::DeleteEventSubscription>
1458  
1459 Returns: a L<Paws::Neptune::DeleteEventSubscriptionResult> instance
1460  
1461 Deletes an event notification subscription.
1462  
1463  
1464 =head2 DescribeDBClusterEndpoints
1465  
1466 =over
1467  
1468 =item [DBClusterEndpointIdentifier => Str]
1469  
1470 =item [DBClusterIdentifier => Str]
1471  
1472 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1473  
1474 =item [Marker => Str]
1475  
1476 =item [MaxRecords => Int]
1477  
1478  
1479 =back
1480  
1481 Each argument is described in detail in: L<Paws::Neptune::DescribeDBClusterEndpoints>
1482  
1483 Returns: a L<Paws::Neptune::DBClusterEndpointMessage> instance
1484  
1485 Returns information about endpoints for an Amazon Neptune DB cluster.
1486  
1487 This operation can also return information for Amazon RDS clusters and
1488 Amazon DocDB clusters.
1489  
1490  
1491 =head2 DescribeDBClusterParameterGroups
1492  
1493 =over
1494  
1495 =item [DBClusterParameterGroupName => Str]
1496  
1497 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1498  
1499 =item [Marker => Str]
1500  
1501 =item [MaxRecords => Int]
1502  
1503  
1504 =back
1505  
1506 Each argument is described in detail in: L<Paws::Neptune::DescribeDBClusterParameterGroups>
1507  
1508 Returns: a L<Paws::Neptune::DBClusterParameterGroupsMessage> instance
1509  
1510 Returns a list of C<DBClusterParameterGroup> descriptions. If a
1511 C<DBClusterParameterGroupName> parameter is specified, the list will
1512 contain only the description of the specified DB cluster parameter
1513 group.
1514  
1515  
1516 =head2 DescribeDBClusterParameters
1517  
1518 =over
1519  
1520 =item DBClusterParameterGroupName => Str
1521  
1522 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1523  
1524 =item [Marker => Str]
1525  
1526 =item [MaxRecords => Int]
1527  
1528 =item [Source => Str]
1529  
1530  
1531 =back
1532  
1533 Each argument is described in detail in: L<Paws::Neptune::DescribeDBClusterParameters>
1534  
1535 Returns: a L<Paws::Neptune::DBClusterParameterGroupDetails> instance
1536  
1537 Returns the detailed parameter list for a particular DB cluster
1538 parameter group.
1539  
1540  
1541 =head2 DescribeDBClusters
1542  
1543 =over
1544  
1545 =item [DBClusterIdentifier => Str]
1546  
1547 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1548  
1549 =item [Marker => Str]
1550  
1551 =item [MaxRecords => Int]
1552  
1553  
1554 =back
1555  
1556 Each argument is described in detail in: L<Paws::Neptune::DescribeDBClusters>
1557  
1558 Returns: a L<Paws::Neptune::DBClusterMessage> instance
1559  
1560 Returns information about provisioned DB clusters, and supports
1561 pagination.
1562  
1563 This operation can also return information for Amazon RDS clusters and
1564 Amazon DocDB clusters.
1565  
1566  
1567 =head2 DescribeDBClusterSnapshotAttributes
1568  
1569 =over
1570  
1571 =item DBClusterSnapshotIdentifier => Str
1572  
1573  
1574 =back
1575  
1576 Each argument is described in detail in: L<Paws::Neptune::DescribeDBClusterSnapshotAttributes>
1577  
1578 Returns: a L<Paws::Neptune::DescribeDBClusterSnapshotAttributesResult> instance
1579  
1580 Returns a list of DB cluster snapshot attribute names and values for a
1581 manual DB cluster snapshot.
1582  
1583 When sharing snapshots with other Amazon accounts,
1584 C<DescribeDBClusterSnapshotAttributes> returns the C<restore> attribute
1585 and a list of IDs for the Amazon accounts that are authorized to copy
1586 or restore the manual DB cluster snapshot. If C<all> is included in the
1587 list of values for the C<restore> attribute, then the manual DB cluster
1588 snapshot is public and can be copied or restored by all Amazon
1589 accounts.
1590  
1591 To add or remove access for an Amazon account to copy or restore a
1592 manual DB cluster snapshot, or to make the manual DB cluster snapshot
1593 public or private, use the ModifyDBClusterSnapshotAttribute API action.
1594  
1595  
1596 =head2 DescribeDBClusterSnapshots
1597  
1598 =over
1599  
1600 =item [DBClusterIdentifier => Str]
1601  
1602 =item [DBClusterSnapshotIdentifier => Str]
1603  
1604 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1605  
1606 =item [IncludePublic => Bool]
1607  
1608 =item [IncludeShared => Bool]
1609  
1610 =item [Marker => Str]
1611  
1612 =item [MaxRecords => Int]
1613  
1614 =item [SnapshotType => Str]
1615  
1616  
1617 =back
1618  
1619 Each argument is described in detail in: L<Paws::Neptune::DescribeDBClusterSnapshots>
1620  
1621 Returns: a L<Paws::Neptune::DBClusterSnapshotMessage> instance
1622  
1623 Returns information about DB cluster snapshots. This API action
1624 supports pagination.
1625  
1626  
1627 =head2 DescribeDBEngineVersions
1628  
1629 =over
1630  
1631 =item [DBParameterGroupFamily => Str]
1632  
1633 =item [DefaultOnly => Bool]
1634  
1635 =item [Engine => Str]
1636  
1637 =item [EngineVersion => Str]
1638  
1639 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1640  
1641 =item [ListSupportedCharacterSets => Bool]
1642  
1643 =item [ListSupportedTimezones => Bool]
1644  
1645 =item [Marker => Str]
1646  
1647 =item [MaxRecords => Int]
1648  
1649  
1650 =back
1651  
1652 Each argument is described in detail in: L<Paws::Neptune::DescribeDBEngineVersions>
1653  
1654 Returns: a L<Paws::Neptune::DBEngineVersionMessage> instance
1655  
1656 Returns a list of the available DB engines.
1657  
1658  
1659 =head2 DescribeDBInstances
1660  
1661 =over
1662  
1663 =item [DBInstanceIdentifier => Str]
1664  
1665 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1666  
1667 =item [Marker => Str]
1668  
1669 =item [MaxRecords => Int]
1670  
1671  
1672 =back
1673  
1674 Each argument is described in detail in: L<Paws::Neptune::DescribeDBInstances>
1675  
1676 Returns: a L<Paws::Neptune::DBInstanceMessage> instance
1677  
1678 Returns information about provisioned instances, and supports
1679 pagination.
1680  
1681 This operation can also return information for Amazon RDS instances and
1682 Amazon DocDB instances.
1683  
1684  
1685 =head2 DescribeDBParameterGroups
1686  
1687 =over
1688  
1689 =item [DBParameterGroupName => Str]
1690  
1691 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1692  
1693 =item [Marker => Str]
1694  
1695 =item [MaxRecords => Int]
1696  
1697  
1698 =back
1699  
1700 Each argument is described in detail in: L<Paws::Neptune::DescribeDBParameterGroups>
1701  
1702 Returns: a L<Paws::Neptune::DBParameterGroupsMessage> instance
1703  
1704 Returns a list of C<DBParameterGroup> descriptions. If a
1705 C<DBParameterGroupName> is specified, the list will contain only the
1706 description of the specified DB parameter group.
1707  
1708  
1709 =head2 DescribeDBParameters
1710  
1711 =over
1712  
1713 =item DBParameterGroupName => Str
1714  
1715 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1716  
1717 =item [Marker => Str]
1718  
1719 =item [MaxRecords => Int]
1720  
1721 =item [Source => Str]
1722  
1723  
1724 =back
1725  
1726 Each argument is described in detail in: L<Paws::Neptune::DescribeDBParameters>
1727  
1728 Returns: a L<Paws::Neptune::DBParameterGroupDetails> instance
1729  
1730 Returns the detailed parameter list for a particular DB parameter
1731 group.
1732  
1733  
1734 =head2 DescribeDBSubnetGroups
1735  
1736 =over
1737  
1738 =item [DBSubnetGroupName => Str]
1739  
1740 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1741  
1742 =item [Marker => Str]
1743  
1744 =item [MaxRecords => Int]
1745  
1746  
1747 =back
1748  
1749 Each argument is described in detail in: L<Paws::Neptune::DescribeDBSubnetGroups>
1750  
1751 Returns: a L<Paws::Neptune::DBSubnetGroupMessage> instance
1752  
1753 Returns a list of DBSubnetGroup descriptions. If a DBSubnetGroupName is
1754 specified, the list will contain only the descriptions of the specified
1755 DBSubnetGroup.
1756  
1757 For an overview of CIDR ranges, go to the Wikipedia Tutorial
1758 (http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
1759  
1760  
1761 =head2 DescribeEngineDefaultClusterParameters
1762  
1763 =over
1764  
1765 =item DBParameterGroupFamily => Str
1766  
1767 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1768  
1769 =item [Marker => Str]
1770  
1771 =item [MaxRecords => Int]
1772  
1773  
1774 =back
1775  
1776 Each argument is described in detail in: L<Paws::Neptune::DescribeEngineDefaultClusterParameters>
1777  
1778 Returns: a L<Paws::Neptune::DescribeEngineDefaultClusterParametersResult> instance
1779  
1780 Returns the default engine and system parameter information for the
1781 cluster database engine.
1782  
1783  
1784 =head2 DescribeEngineDefaultParameters
1785  
1786 =over
1787  
1788 =item DBParameterGroupFamily => Str
1789  
1790 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1791  
1792 =item [Marker => Str]
1793  
1794 =item [MaxRecords => Int]
1795  
1796  
1797 =back
1798  
1799 Each argument is described in detail in: L<Paws::Neptune::DescribeEngineDefaultParameters>
1800  
1801 Returns: a L<Paws::Neptune::DescribeEngineDefaultParametersResult> instance
1802  
1803 Returns the default engine and system parameter information for the
1804 specified database engine.
1805  
1806  
1807 =head2 DescribeEventCategories
1808  
1809 =over
1810  
1811 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1812  
1813 =item [SourceType => Str]
1814  
1815  
1816 =back
1817  
1818 Each argument is described in detail in: L<Paws::Neptune::DescribeEventCategories>
1819  
1820 Returns: a L<Paws::Neptune::EventCategoriesMessage> instance
1821  
1822 Displays a list of categories for all event source types, or, if
1823 specified, for a specified source type.
1824  
1825  
1826 =head2 DescribeEvents
1827  
1828 =over
1829  
1830 =item [Duration => Int]
1831  
1832 =item [EndTime => Str]
1833  
1834 =item [EventCategories => ArrayRef[Str|Undef]]
1835  
1836 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1837  
1838 =item [Marker => Str]
1839  
1840 =item [MaxRecords => Int]
1841  
1842 =item [SourceIdentifier => Str]
1843  
1844 =item [SourceType => Str]
1845  
1846 =item [StartTime => Str]
1847  
1848  
1849 =back
1850  
1851 Each argument is described in detail in: L<Paws::Neptune::DescribeEvents>
1852  
1853 Returns: a L<Paws::Neptune::EventsMessage> instance
1854  
1855 Returns events related to DB instances, DB security groups, DB
1856 snapshots, and DB parameter groups for the past 14 days. Events
1857 specific to a particular DB instance, DB security group, database
1858 snapshot, or DB parameter group can be obtained by providing the name
1859 as a parameter. By default, the past hour of events are returned.
1860  
1861  
1862 =head2 DescribeEventSubscriptions
1863  
1864 =over
1865  
1866 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1867  
1868 =item [Marker => Str]
1869  
1870 =item [MaxRecords => Int]
1871  
1872 =item [SubscriptionName => Str]
1873  
1874  
1875 =back
1876  
1877 Each argument is described in detail in: L<Paws::Neptune::DescribeEventSubscriptions>
1878  
1879 Returns: a L<Paws::Neptune::EventSubscriptionsMessage> instance
1880  
1881 Lists all the subscription descriptions for a customer account. The
1882 description for a subscription includes SubscriptionName, SNSTopicARN,
1883 CustomerID, SourceType, SourceID, CreationTime, and Status.
1884  
1885 If you specify a SubscriptionName, lists the description for that
1886 subscription.
1887  
1888  
1889 =head2 DescribeOrderableDBInstanceOptions
1890  
1891 =over
1892  
1893 =item Engine => Str
1894  
1895 =item [DBInstanceClass => Str]
1896  
1897 =item [EngineVersion => Str]
1898  
1899 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1900  
1901 =item [LicenseModel => Str]
1902  
1903 =item [Marker => Str]
1904  
1905 =item [MaxRecords => Int]
1906  
1907 =item [Vpc => Bool]
1908  
1909  
1910 =back
1911  
1912 Each argument is described in detail in: L<Paws::Neptune::DescribeOrderableDBInstanceOptions>
1913  
1914 Returns: a L<Paws::Neptune::OrderableDBInstanceOptionsMessage> instance
1915  
1916 Returns a list of orderable DB instance options for the specified
1917 engine.
1918  
1919  
1920 =head2 DescribePendingMaintenanceActions
1921  
1922 =over
1923  
1924 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1925  
1926 =item [Marker => Str]
1927  
1928 =item [MaxRecords => Int]
1929  
1930 =item [ResourceIdentifier => Str]
1931  
1932  
1933 =back
1934  
1935 Each argument is described in detail in: L<Paws::Neptune::DescribePendingMaintenanceActions>
1936  
1937 Returns: a L<Paws::Neptune::PendingMaintenanceActionsMessage> instance
1938  
1939 Returns a list of resources (for example, DB instances) that have at
1940 least one pending maintenance action.
1941  
1942  
1943 =head2 DescribeValidDBInstanceModifications
1944  
1945 =over
1946  
1947 =item DBInstanceIdentifier => Str
1948  
1949  
1950 =back
1951  
1952 Each argument is described in detail in: L<Paws::Neptune::DescribeValidDBInstanceModifications>
1953  
1954 Returns: a L<Paws::Neptune::DescribeValidDBInstanceModificationsResult> instance
1955  
1956 You can call DescribeValidDBInstanceModifications to learn what
1957 modifications you can make to your DB instance. You can use this
1958 information when you call ModifyDBInstance.
1959  
1960  
1961 =head2 FailoverDBCluster
1962  
1963 =over
1964  
1965 =item [DBClusterIdentifier => Str]
1966  
1967 =item [TargetDBInstanceIdentifier => Str]
1968  
1969  
1970 =back
1971  
1972 Each argument is described in detail in: L<Paws::Neptune::FailoverDBCluster>
1973  
1974 Returns: a L<Paws::Neptune::FailoverDBClusterResult> instance
1975  
1976 Forces a failover for a DB cluster.
1977  
1978 A failover for a DB cluster promotes one of the Read Replicas
1979 (read-only instances) in the DB cluster to be the primary instance (the
1980 cluster writer).
1981  
1982 Amazon Neptune will automatically fail over to a Read Replica, if one
1983 exists, when the primary instance fails. You can force a failover when
1984 you want to simulate a failure of a primary instance for testing.
1985 Because each instance in a DB cluster has its own endpoint address, you
1986 will need to clean up and re-establish any existing connections that
1987 use those endpoint addresses when the failover is complete.
1988  
1989  
1990 =head2 ListTagsForResource
1991  
1992 =over
1993  
1994 =item ResourceName => Str
1995  
1996 =item [Filters => ArrayRef[L<Paws::Neptune::Filter>]]
1997  
1998  
1999 =back
2000  
2001 Each argument is described in detail in: L<Paws::Neptune::ListTagsForResource>
2002  
2003 Returns: a L<Paws::Neptune::TagListMessage> instance
2004  
2005 Lists all tags on an Amazon Neptune resource.
2006  
2007  
2008 =head2 ModifyDBCluster
2009  
2010 =over
2011  
2012 =item DBClusterIdentifier => Str
2013  
2014 =item [ApplyImmediately => Bool]
2015  
2016 =item [BackupRetentionPeriod => Int]
2017  
2018 =item [CloudwatchLogsExportConfiguration => L<Paws::Neptune::CloudwatchLogsExportConfiguration>]
2019  
2020 =item [CopyTagsToSnapshot => Bool]
2021  
2022 =item [DBClusterParameterGroupName => Str]
2023  
2024 =item [DeletionProtection => Bool]
2025  
2026 =item [EnableIAMDatabaseAuthentication => Bool]
2027  
2028 =item [EngineVersion => Str]
2029  
2030 =item [MasterUserPassword => Str]
2031  
2032 =item [NewDBClusterIdentifier => Str]
2033  
2034 =item [OptionGroupName => Str]
2035  
2036 =item [Port => Int]
2037  
2038 =item [PreferredBackupWindow => Str]
2039  
2040 =item [PreferredMaintenanceWindow => Str]
2041  
2042 =item [VpcSecurityGroupIds => ArrayRef[Str|Undef]]
2043  
2044  
2045 =back
2046  
2047 Each argument is described in detail in: L<Paws::Neptune::ModifyDBCluster>
2048  
2049 Returns: a L<Paws::Neptune::ModifyDBClusterResult> instance
2050  
2051 Modify a setting for a DB cluster. You can change one or more database
2052 configuration parameters by specifying these parameters and the new
2053 values in the request.
2054  
2055  
2056 =head2 ModifyDBClusterEndpoint
2057  
2058 =over
2059  
2060 =item DBClusterEndpointIdentifier => Str
2061  
2062 =item [EndpointType => Str]
2063  
2064 =item [ExcludedMembers => ArrayRef[Str|Undef]]
2065  
2066 =item [StaticMembers => ArrayRef[Str|Undef]]
2067  
2068  
2069 =back
2070  
2071 Each argument is described in detail in: L<Paws::Neptune::ModifyDBClusterEndpoint>
2072  
2073 Returns: a L<Paws::Neptune::ModifyDBClusterEndpointOutput> instance
2074  
2075 Modifies the properties of an endpoint in an Amazon Neptune DB cluster.
2076  
2077  
2078 =head2 ModifyDBClusterParameterGroup
2079  
2080 =over
2081  
2082 =item DBClusterParameterGroupName => Str
2083  
2084 =item Parameters => ArrayRef[L<Paws::Neptune::Parameter>]
2085  
2086  
2087 =back
2088  
2089 Each argument is described in detail in: L<Paws::Neptune::ModifyDBClusterParameterGroup>
2090  
2091 Returns: a L<Paws::Neptune::DBClusterParameterGroupNameMessage> instance
2092  
2093 Modifies the parameters of a DB cluster parameter group. To modify more
2094 than one parameter, submit a list of the following: C<ParameterName>,
2095 C<ParameterValue>, and C<ApplyMethod>. A maximum of 20 parameters can
2096 be modified in a single request.
2097  
2098 Changes to dynamic parameters are applied immediately. Changes to
2099 static parameters require a reboot without failover to the DB cluster
2100 associated with the parameter group before the change can take effect.
2101  
2102 After you create a DB cluster parameter group, you should wait at least
2103 5 minutes before creating your first DB cluster that uses that DB
2104 cluster parameter group as the default parameter group. This allows
2105 Amazon Neptune to fully complete the create action before the parameter
2106 group is used as the default for a new DB cluster. This is especially
2107 important for parameters that are critical when creating the default
2108 database for a DB cluster, such as the character set for the default
2109 database defined by the C<character_set_database> parameter. You can
2110 use the I<Parameter Groups> option of the Amazon Neptune console or the
2111 DescribeDBClusterParameters command to verify that your DB cluster
2112 parameter group has been created or modified.
2113  
2114  
2115 =head2 ModifyDBClusterSnapshotAttribute
2116  
2117 =over
2118  
2119 =item AttributeName => Str
2120  
2121 =item DBClusterSnapshotIdentifier => Str
2122  
2123 =item [ValuesToAdd => ArrayRef[Str|Undef]]
2124  
2125 =item [ValuesToRemove => ArrayRef[Str|Undef]]
2126  
2127  
2128 =back
2129  
2130 Each argument is described in detail in: L<Paws::Neptune::ModifyDBClusterSnapshotAttribute>
2131  
2132 Returns: a L<Paws::Neptune::ModifyDBClusterSnapshotAttributeResult> instance
2133  
2134 Adds an attribute and values to, or removes an attribute and values
2135 from, a manual DB cluster snapshot.
2136  
2137 To share a manual DB cluster snapshot with other Amazon accounts,
2138 specify C<restore> as the C<AttributeName> and use the C<ValuesToAdd>
2139 parameter to add a list of IDs of the Amazon accounts that are
2140 authorized to restore the manual DB cluster snapshot. Use the value
2141 C<all> to make the manual DB cluster snapshot public, which means that
2142 it can be copied or restored by all Amazon accounts. Do not add the
2143 C<all> value for any manual DB cluster snapshots that contain private
2144 information that you don't want available to all Amazon accounts. If a
2145 manual DB cluster snapshot is encrypted, it can be shared, but only by
2146 specifying a list of authorized Amazon account IDs for the
2147 C<ValuesToAdd> parameter. You can't use C<all> as a value for that
2148 parameter in this case.
2149  
2150 To view which Amazon accounts have access to copy or restore a manual
2151 DB cluster snapshot, or whether a manual DB cluster snapshot public or
2152 private, use the DescribeDBClusterSnapshotAttributes API action.
2153  
2154  
2155 =head2 ModifyDBInstance
2156  
2157 =over
2158  
2159 =item DBInstanceIdentifier => Str
2160  
2161 =item [AllocatedStorage => Int]
2162  
2163 =item [AllowMajorVersionUpgrade => Bool]
2164  
2165 =item [ApplyImmediately => Bool]
2166  
2167 =item [AutoMinorVersionUpgrade => Bool]
2168  
2169 =item [BackupRetentionPeriod => Int]
2170  
2171 =item [CACertificateIdentifier => Str]
2172  
2173 =item [CloudwatchLogsExportConfiguration => L<Paws::Neptune::CloudwatchLogsExportConfiguration>]
2174  
2175 =item [CopyTagsToSnapshot => Bool]
2176  
2177 =item [DBInstanceClass => Str]
2178  
2179 =item [DBParameterGroupName => Str]
2180  
2181 =item [DBPortNumber => Int]
2182  
2183 =item [DBSecurityGroups => ArrayRef[Str|Undef]]
2184  
2185 =item [DBSubnetGroupName => Str]
2186  
2187 =item [DeletionProtection => Bool]
2188  
2189 =item [Domain => Str]
2190  
2191 =item [DomainIAMRoleName => Str]
2192  
2193 =item [EnableIAMDatabaseAuthentication => Bool]
2194  
2195 =item [EnablePerformanceInsights => Bool]
2196  
2197 =item [EngineVersion => Str]
2198  
2199 =item [Iops => Int]
2200  
2201 =item [LicenseModel => Str]
2202  
2203 =item [MasterUserPassword => Str]
2204  
2205 =item [MonitoringInterval => Int]
2206  
2207 =item [MonitoringRoleArn => Str]
2208  
2209 =item [MultiAZ => Bool]
2210  
2211 =item [NewDBInstanceIdentifier => Str]
2212  
2213 =item [OptionGroupName => Str]
2214  
2215 =item [PerformanceInsightsKMSKeyId => Str]
2216  
2217 =item [PreferredBackupWindow => Str]
2218  
2219 =item [PreferredMaintenanceWindow => Str]
2220  
2221 =item [PromotionTier => Int]
2222  
2223 =item [PubliclyAccessible => Bool]
2224  
2225 =item [StorageType => Str]
2226  
2227 =item [TdeCredentialArn => Str]
2228  
2229 =item [TdeCredentialPassword => Str]
2230  
2231 =item [VpcSecurityGroupIds => ArrayRef[Str|Undef]]
2232  
2233  
2234 =back
2235  
2236 Each argument is described in detail in: L<Paws::Neptune::ModifyDBInstance>
2237  
2238 Returns: a L<Paws::Neptune::ModifyDBInstanceResult> instance
2239  
2240 Modifies settings for a DB instance. You can change one or more
2241 database configuration parameters by specifying these parameters and
2242 the new values in the request. To learn what modifications you can make
2243 to your DB instance, call DescribeValidDBInstanceModifications before
2244 you call ModifyDBInstance.
2245  
2246  
2247 =head2 ModifyDBParameterGroup
2248  
2249 =over
2250  
2251 =item DBParameterGroupName => Str
2252  
2253 =item Parameters => ArrayRef[L<Paws::Neptune::Parameter>]
2254  
2255  
2256 =back
2257  
2258 Each argument is described in detail in: L<Paws::Neptune::ModifyDBParameterGroup>
2259  
2260 Returns: a L<Paws::Neptune::DBParameterGroupNameMessage> instance
2261  
2262 Modifies the parameters of a DB parameter group. To modify more than
2263 one parameter, submit a list of the following: C<ParameterName>,
2264 C<ParameterValue>, and C<ApplyMethod>. A maximum of 20 parameters can
2265 be modified in a single request.
2266  
2267 Changes to dynamic parameters are applied immediately. Changes to
2268 static parameters require a reboot without failover to the DB instance
2269 associated with the parameter group before the change can take effect.
2270  
2271 After you modify a DB parameter group, you should wait at least 5
2272 minutes before creating your first DB instance that uses that DB
2273 parameter group as the default parameter group. This allows Amazon
2274 Neptune to fully complete the modify action before the parameter group
2275 is used as the default for a new DB instance. This is especially
2276 important for parameters that are critical when creating the default
2277 database for a DB instance, such as the character set for the default
2278 database defined by the C<character_set_database> parameter. You can
2279 use the I<Parameter Groups> option of the Amazon Neptune console or the
2280 I<DescribeDBParameters> command to verify that your DB parameter group
2281 has been created or modified.
2282  
2283  
2284 =head2 ModifyDBSubnetGroup
2285  
2286 =over
2287  
2288 =item DBSubnetGroupName => Str
2289  
2290 =item SubnetIds => ArrayRef[Str|Undef]
2291  
2292 =item [DBSubnetGroupDescription => Str]
2293  
2294  
2295 =back
2296  
2297 Each argument is described in detail in: L<Paws::Neptune::ModifyDBSubnetGroup>
2298  
2299 Returns: a L<Paws::Neptune::ModifyDBSubnetGroupResult> instance
2300  
2301 Modifies an existing DB subnet group. DB subnet groups must contain at
2302 least one subnet in at least two AZs in the Amazon Region.
2303  
2304  
2305 =head2 ModifyEventSubscription
2306  
2307 =over
2308  
2309 =item SubscriptionName => Str
2310  
2311 =item [Enabled => Bool]
2312  
2313 =item [EventCategories => ArrayRef[Str|Undef]]
2314  
2315 =item [SnsTopicArn => Str]
2316  
2317 =item [SourceType => Str]
2318  
2319  
2320 =back
2321  
2322 Each argument is described in detail in: L<Paws::Neptune::ModifyEventSubscription>
2323  
2324 Returns: a L<Paws::Neptune::ModifyEventSubscriptionResult> instance
2325  
2326 Modifies an existing event notification subscription. Note that you
2327 can't modify the source identifiers using this call; to change source
2328 identifiers for a subscription, use the
2329 AddSourceIdentifierToSubscription and
2330 RemoveSourceIdentifierFromSubscription calls.
2331  
2332 You can see a list of the event categories for a given SourceType by
2333 using the B<DescribeEventCategories> action.
2334  
2335  
2336 =head2 PromoteReadReplicaDBCluster
2337  
2338 =over
2339  
2340 =item DBClusterIdentifier => Str
2341  
2342  
2343 =back
2344  
2345 Each argument is described in detail in: L<Paws::Neptune::PromoteReadReplicaDBCluster>
2346  
2347 Returns: a L<Paws::Neptune::PromoteReadReplicaDBClusterResult> instance
2348  
2349 Not supported.
2350  
2351  
2352 =head2 RebootDBInstance
2353  
2354 =over
2355  
2356 =item DBInstanceIdentifier => Str
2357  
2358 =item [ForceFailover => Bool]
2359  
2360  
2361 =back
2362  
2363 Each argument is described in detail in: L<Paws::Neptune::RebootDBInstance>
2364  
2365 Returns: a L<Paws::Neptune::RebootDBInstanceResult> instance
2366  
2367 You might need to reboot your DB instance, usually for maintenance
2368 reasons. For example, if you make certain modifications, or if you
2369 change the DB parameter group associated with the DB instance, you must
2370 reboot the instance for the changes to take effect.
2371  
2372 Rebooting a DB instance restarts the database engine service. Rebooting
2373 a DB instance results in a momentary outage, during which the DB
2374 instance status is set to rebooting.
2375  
2376  
2377 =head2 RemoveRoleFromDBCluster
2378  
2379 =over
2380  
2381 =item DBClusterIdentifier => Str
2382  
2383 =item RoleArn => Str
2384  
2385 =item [FeatureName => Str]
2386  
2387  
2388 =back
2389  
2390 Each argument is described in detail in: L<Paws::Neptune::RemoveRoleFromDBCluster>
2391  
2392 Returns: nothing
2393  
2394 Disassociates an Identity and Access Management (IAM) role from a DB
2395 cluster.
2396  
2397  
2398 =head2 RemoveSourceIdentifierFromSubscription
2399  
2400 =over
2401  
2402 =item SourceIdentifier => Str
2403  
2404 =item SubscriptionName => Str
2405  
2406  
2407 =back
2408  
2409 Each argument is described in detail in: L<Paws::Neptune::RemoveSourceIdentifierFromSubscription>
2410  
2411 Returns: a L<Paws::Neptune::RemoveSourceIdentifierFromSubscriptionResult> instance
2412  
2413 Removes a source identifier from an existing event notification
2414 subscription.
2415  
2416  
2417 =head2 RemoveTagsFromResource
2418  
2419 =over
2420  
2421 =item ResourceName => Str
2422  
2423 =item TagKeys => ArrayRef[Str|Undef]
2424  
2425  
2426 =back
2427  
2428 Each argument is described in detail in: L<Paws::Neptune::RemoveTagsFromResource>
2429  
2430 Returns: nothing
2431  
2432 Removes metadata tags from an Amazon Neptune resource.
2433  
2434  
2435 =head2 ResetDBClusterParameterGroup
2436  
2437 =over
2438  
2439 =item DBClusterParameterGroupName => Str
2440  
2441 =item [Parameters => ArrayRef[L<Paws::Neptune::Parameter>]]
2442  
2443 =item [ResetAllParameters => Bool]
2444  
2445  
2446 =back
2447  
2448 Each argument is described in detail in: L<Paws::Neptune::ResetDBClusterParameterGroup>
2449  
2450 Returns: a L<Paws::Neptune::DBClusterParameterGroupNameMessage> instance
2451  
2452 Modifies the parameters of a DB cluster parameter group to the default
2453 value. To reset specific parameters submit a list of the following:
2454 C<ParameterName> and C<ApplyMethod>. To reset the entire DB cluster
2455 parameter group, specify the C<DBClusterParameterGroupName> and
2456 C<ResetAllParameters> parameters.
2457  
2458 When resetting the entire group, dynamic parameters are updated
2459 immediately and static parameters are set to C<pending-reboot> to take
2460 effect on the next DB instance restart or RebootDBInstance request. You
2461 must call RebootDBInstance for every DB instance in your DB cluster
2462 that you want the updated static parameter to apply to.
2463  
2464  
2465 =head2 ResetDBParameterGroup
2466  
2467 =over
2468  
2469 =item DBParameterGroupName => Str
2470  
2471 =item [Parameters => ArrayRef[L<Paws::Neptune::Parameter>]]
2472  
2473 =item [ResetAllParameters => Bool]
2474  
2475  
2476 =back
2477  
2478 Each argument is described in detail in: L<Paws::Neptune::ResetDBParameterGroup>
2479  
2480 Returns: a L<Paws::Neptune::DBParameterGroupNameMessage> instance
2481  
2482 Modifies the parameters of a DB parameter group to the engine/system
2483 default value. To reset specific parameters, provide a list of the
2484 following: C<ParameterName> and C<ApplyMethod>. To reset the entire DB
2485 parameter group, specify the C<DBParameterGroup> name and
2486 C<ResetAllParameters> parameters. When resetting the entire group,
2487 dynamic parameters are updated immediately and static parameters are
2488 set to C<pending-reboot> to take effect on the next DB instance restart
2489 or C<RebootDBInstance> request.
2490  
2491  
2492 =head2 RestoreDBClusterFromSnapshot
2493  
2494 =over
2495  
2496 =item DBClusterIdentifier => Str
2497  
2498 =item Engine => Str
2499  
2500 =item SnapshotIdentifier => Str
2501  
2502 =item [AvailabilityZones => ArrayRef[Str|Undef]]
2503  
2504 =item [CopyTagsToSnapshot => Bool]
2505  
2506 =item [DatabaseName => Str]
2507  
2508 =item [DBClusterParameterGroupName => Str]
2509  
2510 =item [DBSubnetGroupName => Str]
2511  
2512 =item [DeletionProtection => Bool]
2513  
2514 =item [EnableCloudwatchLogsExports => ArrayRef[Str|Undef]]
2515  
2516 =item [EnableIAMDatabaseAuthentication => Bool]
2517  
2518 =item [EngineVersion => Str]
2519  
2520 =item [KmsKeyId => Str]
2521  
2522 =item [OptionGroupName => Str]
2523  
2524 =item [Port => Int]
2525  
2526 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
2527  
2528 =item [VpcSecurityGroupIds => ArrayRef[Str|Undef]]
2529  
2530  
2531 =back
2532  
2533 Each argument is described in detail in: L<Paws::Neptune::RestoreDBClusterFromSnapshot>
2534  
2535 Returns: a L<Paws::Neptune::RestoreDBClusterFromSnapshotResult> instance
2536  
2537 Creates a new DB cluster from a DB snapshot or DB cluster snapshot.
2538  
2539 If a DB snapshot is specified, the target DB cluster is created from
2540 the source DB snapshot with a default configuration and default
2541 security group.
2542  
2543 If a DB cluster snapshot is specified, the target DB cluster is created
2544 from the source DB cluster restore point with the same configuration as
2545 the original source DB cluster, except that the new DB cluster is
2546 created with the default security group.
2547  
2548  
2549 =head2 RestoreDBClusterToPointInTime
2550  
2551 =over
2552  
2553 =item DBClusterIdentifier => Str
2554  
2555 =item SourceDBClusterIdentifier => Str
2556  
2557 =item [DBClusterParameterGroupName => Str]
2558  
2559 =item [DBSubnetGroupName => Str]
2560  
2561 =item [DeletionProtection => Bool]
2562  
2563 =item [EnableCloudwatchLogsExports => ArrayRef[Str|Undef]]
2564  
2565 =item [EnableIAMDatabaseAuthentication => Bool]
2566  
2567 =item [KmsKeyId => Str]
2568  
2569 =item [OptionGroupName => Str]
2570  
2571 =item [Port => Int]
2572  
2573 =item [RestoreToTime => Str]
2574  
2575 =item [RestoreType => Str]
2576  
2577 =item [Tags => ArrayRef[L<Paws::Neptune::Tag>]]
2578  
2579 =item [UseLatestRestorableTime => Bool]
2580  
2581 =item [VpcSecurityGroupIds => ArrayRef[Str|Undef]]
2582  
2583  
2584 =back
2585  
2586 Each argument is described in detail in: L<Paws::Neptune::RestoreDBClusterToPointInTime>
2587  
2588 Returns: a L<Paws::Neptune::RestoreDBClusterToPointInTimeResult> instance
2589  
2590 Restores a DB cluster to an arbitrary point in time. Users can restore
2591 to any point in time before C<LatestRestorableTime> for up to
2592 C<BackupRetentionPeriod> days. The target DB cluster is created from
2593 the source DB cluster with the same configuration as the original DB
2594 cluster, except that the new DB cluster is created with the default DB
2595 security group.
2596  
2597 This action only restores the DB cluster, not the DB instances for that
2598 DB cluster. You must invoke the CreateDBInstance action to create DB
2599 instances for the restored DB cluster, specifying the identifier of the
2600 restored DB cluster in C<DBClusterIdentifier>. You can create DB
2601 instances only after the C<RestoreDBClusterToPointInTime> action has
2602 completed and the DB cluster is available.
2603  
2604  
2605 =head2 StartDBCluster
2606  
2607 =over
2608  
2609 =item DBClusterIdentifier => Str
2610  
2611  
2612 =back
2613  
2614 Each argument is described in detail in: L<Paws::Neptune::StartDBCluster>
2615  
2616 Returns: a L<Paws::Neptune::StartDBClusterResult> instance
2617  
2618 Starts an Amazon Neptune DB cluster that was stopped using the AWS
2619 console, the Amazon CLI stop-db-cluster command, or the StopDBCluster
2620 API.
2621  
2622  
2623 =head2 StopDBCluster
2624  
2625 =over
2626  
2627 =item DBClusterIdentifier => Str
2628  
2629  
2630 =back
2631  
2632 Each argument is described in detail in: L<Paws::Neptune::StopDBCluster>
2633  
2634 Returns: a L<Paws::Neptune::StopDBClusterResult> instance
2635  
2636 Stops an Amazon Neptune DB cluster. When you stop a DB cluster, Neptune
2637 retains the DB cluster's metadata, including its endpoints and DB
2638 parameter groups.
2639  
2640 Neptune also retains the transaction logs so you can do a point-in-time
2641 restore if necessary.
2642  
2643  
2644  
2645  
2646 =head1 PAGINATORS
2647  
2648 Paginator methods are helpers that repetively call methods that return partial results
2649  
2650 =head2 DescribeAllDBClusterEndpoints(sub { },[DBClusterEndpointIdentifier => Str, DBClusterIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2651  
2652 =head2 DescribeAllDBClusterEndpoints([DBClusterEndpointIdentifier => Str, DBClusterIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2653  
2654  
2655 If passed a sub as first parameter, it will call the sub for each element found in :
2656  
2657 - DBClusterEndpoints, passing the object as the first parameter, and the string 'DBClusterEndpoints' as the second parameter
2658  
2659 If not, it will return a a L<Paws::Neptune::DBClusterEndpointMessage> 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.
2660  
2661  
2662 =head2 DescribeAllDBClusterParameterGroups(sub { },[DBClusterParameterGroupName => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2663  
2664 =head2 DescribeAllDBClusterParameterGroups([DBClusterParameterGroupName => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2665  
2666  
2667 If passed a sub as first parameter, it will call the sub for each element found in :
2668  
2669 - DBClusterParameterGroups, passing the object as the first parameter, and the string 'DBClusterParameterGroups' as the second parameter
2670  
2671 If not, it will return a a L<Paws::Neptune::DBClusterParameterGroupsMessage> 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.
2672  
2673  
2674 =head2 DescribeAllDBClusterParameters(sub { },DBClusterParameterGroupName => Str, [Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, Source => Str])
2675  
2676 =head2 DescribeAllDBClusterParameters(DBClusterParameterGroupName => Str, [Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, Source => Str])
2677  
2678  
2679 If passed a sub as first parameter, it will call the sub for each element found in :
2680  
2681 - Parameters, passing the object as the first parameter, and the string 'Parameters' as the second parameter
2682  
2683 If not, it will return a a L<Paws::Neptune::DBClusterParameterGroupDetails> 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.
2684  
2685  
2686 =head2 DescribeAllDBClusters(sub { },[DBClusterIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2687  
2688 =head2 DescribeAllDBClusters([DBClusterIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2689  
2690  
2691 If passed a sub as first parameter, it will call the sub for each element found in :
2692  
2693 - DBClusters, passing the object as the first parameter, and the string 'DBClusters' as the second parameter
2694  
2695 If not, it will return a a L<Paws::Neptune::DBClusterMessage> 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.
2696  
2697  
2698 =head2 DescribeAllDBClusterSnapshots(sub { },[DBClusterIdentifier => Str, DBClusterSnapshotIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], IncludePublic => Bool, IncludeShared => Bool, Marker => Str, MaxRecords => Int, SnapshotType => Str])
2699  
2700 =head2 DescribeAllDBClusterSnapshots([DBClusterIdentifier => Str, DBClusterSnapshotIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], IncludePublic => Bool, IncludeShared => Bool, Marker => Str, MaxRecords => Int, SnapshotType => Str])
2701  
2702  
2703 If passed a sub as first parameter, it will call the sub for each element found in :
2704  
2705 - DBClusterSnapshots, passing the object as the first parameter, and the string 'DBClusterSnapshots' as the second parameter
2706  
2707 If not, it will return a a L<Paws::Neptune::DBClusterSnapshotMessage> 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.
2708  
2709  
2710 =head2 DescribeAllDBEngineVersions(sub { },[DBParameterGroupFamily => Str, DefaultOnly => Bool, Engine => Str, EngineVersion => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], ListSupportedCharacterSets => Bool, ListSupportedTimezones => Bool, Marker => Str, MaxRecords => Int])
2711  
2712 =head2 DescribeAllDBEngineVersions([DBParameterGroupFamily => Str, DefaultOnly => Bool, Engine => Str, EngineVersion => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], ListSupportedCharacterSets => Bool, ListSupportedTimezones => Bool, Marker => Str, MaxRecords => Int])
2713  
2714  
2715 If passed a sub as first parameter, it will call the sub for each element found in :
2716  
2717 - DBEngineVersions, passing the object as the first parameter, and the string 'DBEngineVersions' as the second parameter
2718  
2719 If not, it will return a a L<Paws::Neptune::DBEngineVersionMessage> 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.
2720  
2721  
2722 =head2 DescribeAllDBInstances(sub { },[DBInstanceIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2723  
2724 =head2 DescribeAllDBInstances([DBInstanceIdentifier => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2725  
2726  
2727 If passed a sub as first parameter, it will call the sub for each element found in :
2728  
2729 - DBInstances, passing the object as the first parameter, and the string 'DBInstances' as the second parameter
2730  
2731 If not, it will return a a L<Paws::Neptune::DBInstanceMessage> 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.
2732  
2733  
2734 =head2 DescribeAllDBParameterGroups(sub { },[DBParameterGroupName => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2735  
2736 =head2 DescribeAllDBParameterGroups([DBParameterGroupName => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2737  
2738  
2739 If passed a sub as first parameter, it will call the sub for each element found in :
2740  
2741 - DBParameterGroups, passing the object as the first parameter, and the string 'DBParameterGroups' as the second parameter
2742  
2743 If not, it will return a a L<Paws::Neptune::DBParameterGroupsMessage> 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.
2744  
2745  
2746 =head2 DescribeAllDBParameters(sub { },DBParameterGroupName => Str, [Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, Source => Str])
2747  
2748 =head2 DescribeAllDBParameters(DBParameterGroupName => Str, [Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, Source => Str])
2749  
2750  
2751 If passed a sub as first parameter, it will call the sub for each element found in :
2752  
2753 - Parameters, passing the object as the first parameter, and the string 'Parameters' as the second parameter
2754  
2755 If not, it will return a a L<Paws::Neptune::DBParameterGroupDetails> 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.
2756  
2757  
2758 =head2 DescribeAllDBSubnetGroups(sub { },[DBSubnetGroupName => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2759  
2760 =head2 DescribeAllDBSubnetGroups([DBSubnetGroupName => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2761  
2762  
2763 If passed a sub as first parameter, it will call the sub for each element found in :
2764  
2765 - DBSubnetGroups, passing the object as the first parameter, and the string 'DBSubnetGroups' as the second parameter
2766  
2767 If not, it will return a a L<Paws::Neptune::DBSubnetGroupMessage> 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.
2768  
2769  
2770 =head2 DescribeAllEngineDefaultParameters(sub { },DBParameterGroupFamily => Str, [Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2771  
2772 =head2 DescribeAllEngineDefaultParameters(DBParameterGroupFamily => Str, [Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int])
2773  
2774  
2775 If passed a sub as first parameter, it will call the sub for each element found in :
2776  
2777 - EngineDefaults.Parameters, passing the object as the first parameter, and the string 'EngineDefaults.Parameters' as the second parameter
2778  
2779 If not, it will return a a L<Paws::Neptune::DescribeEngineDefaultParametersResult> 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.
2780  
2781  
2782 =head2 DescribeAllEvents(sub { },[Duration => Int, EndTime => Str, EventCategories => ArrayRef[Str|Undef], Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
2783  
2784 =head2 DescribeAllEvents([Duration => Int, EndTime => Str, EventCategories => ArrayRef[Str|Undef], Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, SourceIdentifier => Str, SourceType => Str, StartTime => Str])
2785  
2786  
2787 If passed a sub as first parameter, it will call the sub for each element found in :
2788  
2789 - Events, passing the object as the first parameter, and the string 'Events' as the second parameter
2790  
2791 If not, it will return a a L<Paws::Neptune::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.
2792  
2793  
2794 =head2 DescribeAllEventSubscriptions(sub { },[Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, SubscriptionName => Str])
2795  
2796 =head2 DescribeAllEventSubscriptions([Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, SubscriptionName => Str])
2797  
2798  
2799 If passed a sub as first parameter, it will call the sub for each element found in :
2800  
2801 - EventSubscriptionsList, passing the object as the first parameter, and the string 'EventSubscriptionsList' as the second parameter
2802  
2803 If not, it will return a a L<Paws::Neptune::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.
2804  
2805  
2806 =head2 DescribeAllOrderableDBInstanceOptions(sub { },Engine => Str, [DBInstanceClass => Str, EngineVersion => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], LicenseModel => Str, Marker => Str, MaxRecords => Int, Vpc => Bool])
2807  
2808 =head2 DescribeAllOrderableDBInstanceOptions(Engine => Str, [DBInstanceClass => Str, EngineVersion => Str, Filters => ArrayRef[L<Paws::Neptune::Filter>], LicenseModel => Str, Marker => Str, MaxRecords => Int, Vpc => Bool])
2809  
2810  
2811 If passed a sub as first parameter, it will call the sub for each element found in :
2812  
2813 - OrderableDBInstanceOptions, passing the object as the first parameter, and the string 'OrderableDBInstanceOptions' as the second parameter
2814  
2815 If not, it will return a a L<Paws::Neptune::OrderableDBInstanceOptionsMessage> 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.
2816  
2817  
2818 =head2 DescribeAllPendingMaintenanceActions(sub { },[Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, ResourceIdentifier => Str])
2819  
2820 =head2 DescribeAllPendingMaintenanceActions([Filters => ArrayRef[L<Paws::Neptune::Filter>], Marker => Str, MaxRecords => Int, ResourceIdentifier => Str])
2821  
2822  
2823 If passed a sub as first parameter, it will call the sub for each element found in :
2824  
2825 - PendingMaintenanceActions, passing the object as the first parameter, and the string 'PendingMaintenanceActions' as the second parameter
2826  
2827 If not, it will return a a L<Paws::Neptune::PendingMaintenanceActionsMessage> 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.
2828  
2829  
2830  
2831  
2832  
2833 =head1 SEE ALSO
2834  
2835 This service class forms part of L<Paws>
2836  
2837 =head1 BUGS and CONTRIBUTIONS
2838  
2839 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
2840  
2841 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
2842  
2843 =cut
2844