blib/lib/Paws/Proton.pm untested

filter: Statementstmt 0.0% 0 / 342 Branchbran 0.0% 0 / 36 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 65 Podpod 0.0% 0 / 64 totaltotal 0.0% 0 / 507 CC 19 SCAR 16.6
CC
19
Cov
0%
ListAllEnvironmentAccountConnections
12.0
ListAllEnvironments
12.0
ListAllEnvironmentTemplates
12.0
CRAP 5.3
1 package Paws::Proton;
2 use Moose;
3 sub service { 'proton' }
4 sub signing_name { 'proton' }
5 sub version { '2020-07-20' }
6 sub target_prefix { 'AwsProton20200720' }
7 sub json_version { "1.0" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub AcceptEnvironmentAccountConnection {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::Proton::AcceptEnvironmentAccountConnection', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CancelEnvironmentDeployment {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::Proton::CancelEnvironmentDeployment', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CancelServiceInstanceDeployment {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::Proton::CancelServiceInstanceDeployment', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CancelServicePipelineDeployment {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::Proton::CancelServicePipelineDeployment', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateEnvironment {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::Proton::CreateEnvironment', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub CreateEnvironmentAccountConnection {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::Proton::CreateEnvironmentAccountConnection', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub CreateEnvironmentTemplate {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::Proton::CreateEnvironmentTemplate', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub CreateEnvironmentTemplateVersion {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::Proton::CreateEnvironmentTemplateVersion', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub CreateService {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::Proton::CreateService', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub CreateServiceTemplate {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::Proton::CreateServiceTemplate', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub CreateServiceTemplateVersion {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::Proton::CreateServiceTemplateVersion', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub DeleteEnvironment {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::Proton::DeleteEnvironment', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub DeleteEnvironmentAccountConnection {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::Proton::DeleteEnvironmentAccountConnection', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub DeleteEnvironmentTemplate {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::Proton::DeleteEnvironmentTemplate', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub DeleteEnvironmentTemplateVersion {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::Proton::DeleteEnvironmentTemplateVersion', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub DeleteService {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::Proton::DeleteService', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub DeleteServiceTemplate {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::Proton::DeleteServiceTemplate', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub DeleteServiceTemplateVersion {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::Proton::DeleteServiceTemplateVersion', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub GetAccountSettings {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::Proton::GetAccountSettings', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub GetEnvironment {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::Proton::GetEnvironment', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub GetEnvironmentAccountConnection {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::Proton::GetEnvironmentAccountConnection', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub GetEnvironmentTemplate {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::Proton::GetEnvironmentTemplate', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub GetEnvironmentTemplateVersion {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::Proton::GetEnvironmentTemplateVersion', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub GetService {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::Proton::GetService', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub GetServiceInstance {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::Proton::GetServiceInstance', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub GetServiceTemplate {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::Proton::GetServiceTemplate', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub GetServiceTemplateVersion {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::Proton::GetServiceTemplateVersion', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub ListEnvironmentAccountConnections {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::Proton::ListEnvironmentAccountConnections', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub ListEnvironments {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::Proton::ListEnvironments', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub ListEnvironmentTemplates {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::Proton::ListEnvironmentTemplates', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub ListEnvironmentTemplateVersions {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::Proton::ListEnvironmentTemplateVersions', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub ListServiceInstances {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::Proton::ListServiceInstances', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub ListServices {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::Proton::ListServices', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub ListServiceTemplates {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::Proton::ListServiceTemplates', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub ListServiceTemplateVersions {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::Proton::ListServiceTemplateVersions', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub ListTagsForResource {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::Proton::ListTagsForResource', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub RejectEnvironmentAccountConnection {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::Proton::RejectEnvironmentAccountConnection', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub TagResource {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::Proton::TagResource', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub UntagResource {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::Proton::UntagResource', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub UpdateAccountSettings {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateAccountSettings', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub UpdateEnvironment {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateEnvironment', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub UpdateEnvironmentAccountConnection {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateEnvironmentAccountConnection', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub UpdateEnvironmentTemplate {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateEnvironmentTemplate', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub UpdateEnvironmentTemplateVersion {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateEnvironmentTemplateVersion', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub UpdateService {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateService', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub UpdateServiceInstance {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateServiceInstance', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub UpdateServicePipeline {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateServicePipeline', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub UpdateServiceTemplate {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateServiceTemplate', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub UpdateServiceTemplateVersion {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::Proton::UpdateServiceTemplateVersion', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263
264 sub ListAllEnvironmentAccountConnections {
265 my $self = shift;
266  
267 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
268 my $result = $self->ListEnvironmentAccountConnections(@_);
269 my $next_result = $result;
270  
271 if (not defined $callback) {
272 while ($next_result->nextToken) {
273 $next_result = $self->ListEnvironmentAccountConnections(@_, nextToken => $next_result->nextToken);
274 push @{ $result->environmentAccountConnections }, @{ $next_result->environmentAccountConnections };
275 }
276 return $result;
277 } else {
278 while ($result->nextToken) {
279 $callback->($_ => 'environmentAccountConnections') foreach (@{ $result->environmentAccountConnections });
280 $result = $self->ListEnvironmentAccountConnections(@_, nextToken => $result->nextToken);
281 }
282 $callback->($_ => 'environmentAccountConnections') foreach (@{ $result->environmentAccountConnections });
283 }
284  
285 return undef
286 }
287 sub ListAllEnvironments {
288 my $self = shift;
289  
290 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
291 my $result = $self->ListEnvironments(@_);
292 my $next_result = $result;
293  
294 if (not defined $callback) {
295 while ($next_result->nextToken) {
296 $next_result = $self->ListEnvironments(@_, nextToken => $next_result->nextToken);
297 push @{ $result->environments }, @{ $next_result->environments };
298 }
299 return $result;
300 } else {
301 while ($result->nextToken) {
302 $callback->($_ => 'environments') foreach (@{ $result->environments });
303 $result = $self->ListEnvironments(@_, nextToken => $result->nextToken);
304 }
305 $callback->($_ => 'environments') foreach (@{ $result->environments });
306 }
307  
308 return undef
309 }
310 sub ListAllEnvironmentTemplates {
311 my $self = shift;
312  
313 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
314 my $result = $self->ListEnvironmentTemplates(@_);
315 my $next_result = $result;
316  
317 if (not defined $callback) {
318 while ($next_result->nextToken) {
319 $next_result = $self->ListEnvironmentTemplates(@_, nextToken => $next_result->nextToken);
320 push @{ $result->templates }, @{ $next_result->templates };
321 }
322 return $result;
323 } else {
324 while ($result->nextToken) {
325 $callback->($_ => 'templates') foreach (@{ $result->templates });
326 $result = $self->ListEnvironmentTemplates(@_, nextToken => $result->nextToken);
327 }
328 $callback->($_ => 'templates') foreach (@{ $result->templates });
329 }
330  
331 return undef
332 }
333 sub ListAllEnvironmentTemplateVersions {
334 my $self = shift;
335  
336 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
337 my $result = $self->ListEnvironmentTemplateVersions(@_);
338 my $next_result = $result;
339  
340 if (not defined $callback) {
341 while ($next_result->nextToken) {
342 $next_result = $self->ListEnvironmentTemplateVersions(@_, nextToken => $next_result->nextToken);
343 push @{ $result->templateVersions }, @{ $next_result->templateVersions };
344 }
345 return $result;
346 } else {
347 while ($result->nextToken) {
348 $callback->($_ => 'templateVersions') foreach (@{ $result->templateVersions });
349 $result = $self->ListEnvironmentTemplateVersions(@_, nextToken => $result->nextToken);
350 }
351 $callback->($_ => 'templateVersions') foreach (@{ $result->templateVersions });
352 }
353  
354 return undef
355 }
356 sub ListAllServiceInstances {
357 my $self = shift;
358  
359 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
360 my $result = $self->ListServiceInstances(@_);
361 my $next_result = $result;
362  
363 if (not defined $callback) {
364 while ($next_result->nextToken) {
365 $next_result = $self->ListServiceInstances(@_, nextToken => $next_result->nextToken);
366 push @{ $result->serviceInstances }, @{ $next_result->serviceInstances };
367 }
368 return $result;
369 } else {
370 while ($result->nextToken) {
371 $callback->($_ => 'serviceInstances') foreach (@{ $result->serviceInstances });
372 $result = $self->ListServiceInstances(@_, nextToken => $result->nextToken);
373 }
374 $callback->($_ => 'serviceInstances') foreach (@{ $result->serviceInstances });
375 }
376  
377 return undef
378 }
379 sub ListAllServices {
380 my $self = shift;
381  
382 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
383 my $result = $self->ListServices(@_);
384 my $next_result = $result;
385  
386 if (not defined $callback) {
387 while ($next_result->nextToken) {
388 $next_result = $self->ListServices(@_, nextToken => $next_result->nextToken);
389 push @{ $result->services }, @{ $next_result->services };
390 }
391 return $result;
392 } else {
393 while ($result->nextToken) {
394 $callback->($_ => 'services') foreach (@{ $result->services });
395 $result = $self->ListServices(@_, nextToken => $result->nextToken);
396 }
397 $callback->($_ => 'services') foreach (@{ $result->services });
398 }
399  
400 return undef
401 }
402 sub ListAllServiceTemplates {
403 my $self = shift;
404  
405 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
406 my $result = $self->ListServiceTemplates(@_);
407 my $next_result = $result;
408  
409 if (not defined $callback) {
410 while ($next_result->nextToken) {
411 $next_result = $self->ListServiceTemplates(@_, nextToken => $next_result->nextToken);
412 push @{ $result->templates }, @{ $next_result->templates };
413 }
414 return $result;
415 } else {
416 while ($result->nextToken) {
417 $callback->($_ => 'templates') foreach (@{ $result->templates });
418 $result = $self->ListServiceTemplates(@_, nextToken => $result->nextToken);
419 }
420 $callback->($_ => 'templates') foreach (@{ $result->templates });
421 }
422  
423 return undef
424 }
425 sub ListAllServiceTemplateVersions {
426 my $self = shift;
427  
428 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
429 my $result = $self->ListServiceTemplateVersions(@_);
430 my $next_result = $result;
431  
432 if (not defined $callback) {
433 while ($next_result->nextToken) {
434 $next_result = $self->ListServiceTemplateVersions(@_, nextToken => $next_result->nextToken);
435 push @{ $result->templateVersions }, @{ $next_result->templateVersions };
436 }
437 return $result;
438 } else {
439 while ($result->nextToken) {
440 $callback->($_ => 'templateVersions') foreach (@{ $result->templateVersions });
441 $result = $self->ListServiceTemplateVersions(@_, nextToken => $result->nextToken);
442 }
443 $callback->($_ => 'templateVersions') foreach (@{ $result->templateVersions });
444 }
445  
446 return undef
447 }
448 sub ListAllTagsForResource {
449 my $self = shift;
450  
451 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
452 my $result = $self->ListTagsForResource(@_);
453 my $next_result = $result;
454  
455 if (not defined $callback) {
456 while ($next_result->nextToken) {
457 $next_result = $self->ListTagsForResource(@_, nextToken => $next_result->nextToken);
458 push @{ $result->tags }, @{ $next_result->tags };
459 }
460 return $result;
461 } else {
462 while ($result->nextToken) {
463 $callback->($_ => 'tags') foreach (@{ $result->tags });
464 $result = $self->ListTagsForResource(@_, nextToken => $result->nextToken);
465 }
466 $callback->($_ => 'tags') foreach (@{ $result->tags });
467 }
468  
469 return undef
470 }
471  
472  
473 sub operations { qw/AcceptEnvironmentAccountConnection CancelEnvironmentDeployment CancelServiceInstanceDeployment CancelServicePipelineDeployment CreateEnvironment CreateEnvironmentAccountConnection CreateEnvironmentTemplate CreateEnvironmentTemplateVersion CreateService CreateServiceTemplate CreateServiceTemplateVersion DeleteEnvironment DeleteEnvironmentAccountConnection DeleteEnvironmentTemplate DeleteEnvironmentTemplateVersion DeleteService DeleteServiceTemplate DeleteServiceTemplateVersion GetAccountSettings GetEnvironment GetEnvironmentAccountConnection GetEnvironmentTemplate GetEnvironmentTemplateVersion GetService GetServiceInstance GetServiceTemplate GetServiceTemplateVersion ListEnvironmentAccountConnections ListEnvironments ListEnvironmentTemplates ListEnvironmentTemplateVersions ListServiceInstances ListServices ListServiceTemplates ListServiceTemplateVersions ListTagsForResource RejectEnvironmentAccountConnection TagResource UntagResource UpdateAccountSettings UpdateEnvironment UpdateEnvironmentAccountConnection UpdateEnvironmentTemplate UpdateEnvironmentTemplateVersion UpdateService UpdateServiceInstance UpdateServicePipeline UpdateServiceTemplate UpdateServiceTemplateVersion / }
474  
475 1;
476  
477 ### main pod documentation begin ###
478  
479 =head1 NAME
480  
481 Paws::Proton - Perl Interface to AWS AWS Proton
482  
483 =head1 SYNOPSIS
484  
485 use Paws;
486  
487 my $obj = Paws->service('Proton');
488 my $res = $obj->Method(
489 Arg1 => $val1,
490 Arg2 => [ 'V1', 'V2' ],
491 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
492 # of the arguments type
493 Arg3 => { Att1 => 'Val1' },
494 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
495 # the constructor of the arguments type
496 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
497 );
498  
499 =head1 DESCRIPTION
500  
501 This is the AWS Proton Service API Reference. It provides descriptions,
502 syntax and usage examples for each of the actions
503 (https://docs.aws.amazon.com/proton/latest/APIReference/API_Operations.html)
504 and data types
505 (https://docs.aws.amazon.com/proton/latest/APIReference/API_Types.html)
506 for the AWS Proton service.
507  
508 The documentation for each action shows the Query API request
509 parameters and the XML response.
510  
511 Alternatively, you can use the AWS CLI to access an API. For more
512 information, see the AWS Command Line Interface User Guide
513 (https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).
514  
515 The AWS Proton service is a two-pronged automation framework.
516 Administrators create service templates to provide standardized
517 infrastructure and deployment tooling for serverless and container
518 based applications. Developers, in turn, select from the available
519 service templates to automate their application or service deployments.
520  
521 Because administrators define the infrastructure and tooling that AWS
522 Proton deploys and manages, they need permissions to use all of the
523 listed API operations.
524  
525 When developers select a specific infrastructure and tooling set, AWS
526 Proton deploys their applications. To monitor their applications that
527 are running on AWS Proton, developers need permissions to the service
528 I<create>, I<list>, I<update> and I<delete> API operations and the
529 service instance I<list> and I<update> API operations.
530  
531 To learn more about AWS Proton administration, see the AWS Proton
532 Administration Guide
533 (https://docs.aws.amazon.com/proton/latest/adminguide/Welcome.html).
534  
535 To learn more about deploying serverless and containerized applications
536 on AWS Proton, see the AWS Proton User Guide
537 (https://docs.aws.amazon.com/proton/latest/userguide/Welcome.html).
538  
539 B<Ensuring Idempotency>
540  
541 When you make a mutating API request, the request typically returns a
542 result before the asynchronous workflows of the operation are complete.
543 Operations might also time out or encounter other server issues before
544 they're complete, even if the request already returned a result. This
545 might make it difficult to determine whether the request succeeded.
546 Moreover, you might need to retry the request multiple times to ensure
547 that the operation completes successfully. However, if the original
548 request and the subsequent retries are successful, the operation occurs
549 multiple times. This means that you might create more resources than
550 you intended.
551  
552 I<Idempotency> ensures that an API request action completes no more
553 than one time. With an idempotent request, if the original request
554 action completes successfully, any subsequent retries complete
555 successfully without performing any further actions. However, the
556 result might contain updated information, such as the current creation
557 status.
558  
559 The following lists of APIs are grouped according to methods that
560 ensure idempotency.
561  
562 B<Idempotent create APIs with a client token>
563  
564 The API actions in this list support idempotency with the use of a
565 I<client token>. The corresponding AWS CLI commands also support
566 idempotency using a client token. A client token is a unique,
567 case-sensitive string of up to 64 ASCII characters. To make an
568 idempotent API request using one of these actions, specify a client
569 token in the request. We recommend that you I<don't> reuse the same
570 client token for other API requests. If you donE<rsquo>t provide a
571 client token for these APIs, a default client token is automatically
572 provided by SDKs.
573  
574 Given a request action that has succeeded:
575  
576 If you retry the request using the same client token and the same
577 parameters, the retry succeeds without performing any further actions
578 other than returning the original resource detail data in the response.
579  
580 If you retry the request using the same client token, but one or more
581 of the parameters are different, the retry throws a
582 C<ValidationException> with an C<IdempotentParameterMismatch> error.
583  
584 Client tokens expire eight hours after a request is made. If you retry
585 the request with the expired token, a new resource is created.
586  
587 If the original resource is deleted and you retry the request, a new
588 resource is created.
589  
590 Idempotent create APIs with a client token:
591  
592 =over
593  
594 =item *
595  
596 CreateEnvironmentTemplateVersion
597  
598 =item *
599  
600 CreateServiceTemplateVersion
601  
602 =item *
603  
604 CreateEnvironmentAccountConnection
605  
606 =back
607  
608 <p> <b>Idempotent delete APIs</b> </p> <p>Given a request action that has succeeded:</p> <p>When you retry the request with an API from this group and the resource was deleted, its metadata is returned in the response.</p> <p>If you retry and the resource doesn't exist, the response is empty.</p> <p>In both cases, the retry succeeds.</p> <p>Idempotent delete APIs:</p> <ul> <li> <p>DeleteEnvironmentTemplate</p> </li> <li> <p>DeleteEnvironmentTemplateVersion</p> </li> <li> <p>DeleteServiceTemplate</p> </li> <li> <p>DeleteServiceTemplateVersion</p> </li> <li> <p>DeleteEnvironmentAccountConnection</p> </li> </ul> <p> <b>Asynchronous idempotent delete APIs</b> </p> <p>Given a request action that has succeeded:</p> <p>If you retry the request with an API from this group, if the original request delete operation status is <code>DELETE_IN_PROGRESS</code>, the retry returns the resource detail data in the response without performing any further actions.</p> <p>If the original request delete operation is complete, a retry returns an empty response.</p> <p>Asynchronous idempotent delete APIs:</p> <ul> <li> <p>DeleteEnvironment</p> </li> <li> <p>DeleteService</p> </li> </ul>
609  
610 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/proton-2020-07-20>
611  
612  
613 =head1 METHODS
614  
615 =head2 AcceptEnvironmentAccountConnection
616  
617 =over
618  
619 =item Id => Str
620  
621  
622 =back
623  
624 Each argument is described in detail in: L<Paws::Proton::AcceptEnvironmentAccountConnection>
625  
626 Returns: a L<Paws::Proton::AcceptEnvironmentAccountConnectionOutput> instance
627  
628 In a management account, an environment account connection request is
629 accepted. When the environment account connection request is accepted,
630 AWS Proton can use the associated IAM role to provision environment
631 infrastructure resources in the associated environment account.
632  
633 For more information, see Environment account connections in the I<AWS
634 Proton Administration guide>.
635  
636  
637 =head2 CancelEnvironmentDeployment
638  
639 =over
640  
641 =item EnvironmentName => Str
642  
643  
644 =back
645  
646 Each argument is described in detail in: L<Paws::Proton::CancelEnvironmentDeployment>
647  
648 Returns: a L<Paws::Proton::CancelEnvironmentDeploymentOutput> instance
649  
650 Attempts to cancel an environment deployment on an UpdateEnvironment
651 action, if the deployment is C<IN_PROGRESS>. For more information, see
652 Update an environment
653 (https://docs.aws.amazon.com/proton/latest/adminguide/ag-env-update.html)
654 in the I<AWS Proton Administration guide>.
655  
656 The following list includes potential cancellation scenarios.
657  
658 =over
659  
660 =item *
661  
662 If the cancellation attempt succeeds, the resulting deployment state is
663 C<CANCELLED>.
664  
665 =item *
666  
667 If the cancellation attempt fails, the resulting deployment state is
668 C<FAILED>.
669  
670 =item *
671  
672 If the current UpdateEnvironment action succeeds before the
673 cancellation attempt starts, the resulting deployment state is
674 C<SUCCEEDED> and the cancellation attempt has no effect.
675  
676 =back
677  
678  
679  
680 =head2 CancelServiceInstanceDeployment
681  
682 =over
683  
684 =item ServiceInstanceName => Str
685  
686 =item ServiceName => Str
687  
688  
689 =back
690  
691 Each argument is described in detail in: L<Paws::Proton::CancelServiceInstanceDeployment>
692  
693 Returns: a L<Paws::Proton::CancelServiceInstanceDeploymentOutput> instance
694  
695 Attempts to cancel a service instance deployment on an
696 UpdateServiceInstance action, if the deployment is C<IN_PROGRESS>. For
697 more information, see I<Update a service instance> in the AWS Proton
698 Administration guide
699 (https://docs.aws.amazon.com/proton/latest/adminguide/ag-svc-instance-update.html)
700 or the AWS Proton User guide
701 (https://docs.aws.amazon.com/proton/latest/userguide/ug-svc-instance-update.html).
702  
703 The following list includes potential cancellation scenarios.
704  
705 =over
706  
707 =item *
708  
709 If the cancellation attempt succeeds, the resulting deployment state is
710 C<CANCELLED>.
711  
712 =item *
713  
714 If the cancellation attempt fails, the resulting deployment state is
715 C<FAILED>.
716  
717 =item *
718  
719 If the current UpdateServiceInstance action succeeds before the
720 cancellation attempt starts, the resulting deployment state is
721 C<SUCCEEDED> and the cancellation attempt has no effect.
722  
723 =back
724  
725  
726  
727 =head2 CancelServicePipelineDeployment
728  
729 =over
730  
731 =item ServiceName => Str
732  
733  
734 =back
735  
736 Each argument is described in detail in: L<Paws::Proton::CancelServicePipelineDeployment>
737  
738 Returns: a L<Paws::Proton::CancelServicePipelineDeploymentOutput> instance
739  
740 Attempts to cancel a service pipeline deployment on an
741 UpdateServicePipeline action, if the deployment is C<IN_PROGRESS>. For
742 more information, see I<Update a service pipeline> in the AWS Proton
743 Administration guide
744 (https://docs.aws.amazon.com/proton/latest/adminguide/ag-svc-pipeline-update.html)
745 or the AWS Proton User guide
746 (https://docs.aws.amazon.com/proton/latest/userguide/ug-svc-pipeline-update.html).
747  
748 The following list includes potential cancellation scenarios.
749  
750 =over
751  
752 =item *
753  
754 If the cancellation attempt succeeds, the resulting deployment state is
755 C<CANCELLED>.
756  
757 =item *
758  
759 If the cancellation attempt fails, the resulting deployment state is
760 C<FAILED>.
761  
762 =item *
763  
764 If the current UpdateServicePipeline action succeeds before the
765 cancellation attempt starts, the resulting deployment state is
766 C<SUCCEEDED> and the cancellation attempt has no effect.
767  
768 =back
769  
770  
771  
772 =head2 CreateEnvironment
773  
774 =over
775  
776 =item Name => Str
777  
778 =item Spec => Str
779  
780 =item TemplateMajorVersion => Str
781  
782 =item TemplateName => Str
783  
784 =item [Description => Str]
785  
786 =item [EnvironmentAccountConnectionId => Str]
787  
788 =item [ProtonServiceRoleArn => Str]
789  
790 =item [Tags => ArrayRef[L<Paws::Proton::Tag>]]
791  
792 =item [TemplateMinorVersion => Str]
793  
794  
795 =back
796  
797 Each argument is described in detail in: L<Paws::Proton::CreateEnvironment>
798  
799 Returns: a L<Paws::Proton::CreateEnvironmentOutput> instance
800  
801 Deploy a new environment. An AWS Proton environment is created from an
802 environment template that defines infrastructure and resources that can
803 be shared across services. For more information, see the Environments
804 (https://docs.aws.amazon.com/proton/latest/adminguide/ag-environments.html)
805 in the I<AWS Proton Administration Guide.>
806  
807  
808 =head2 CreateEnvironmentAccountConnection
809  
810 =over
811  
812 =item EnvironmentName => Str
813  
814 =item ManagementAccountId => Str
815  
816 =item RoleArn => Str
817  
818 =item [ClientToken => Str]
819  
820  
821 =back
822  
823 Each argument is described in detail in: L<Paws::Proton::CreateEnvironmentAccountConnection>
824  
825 Returns: a L<Paws::Proton::CreateEnvironmentAccountConnectionOutput> instance
826  
827 Create an environment account connection in an environment account so
828 that environment infrastructure resources can be provisioned in the
829 environment account from the management account.
830  
831 An environment account connection is a secure bi-directional connection
832 between a I<management account> and an I<environment account> that
833 maintains authorization and permissions. For more information, see
834 Environment account connections in the I<AWS Proton Administration
835 guide>.
836  
837  
838 =head2 CreateEnvironmentTemplate
839  
840 =over
841  
842 =item Name => Str
843  
844 =item [Description => Str]
845  
846 =item [DisplayName => Str]
847  
848 =item [EncryptionKey => Str]
849  
850 =item [Provisioning => Str]
851  
852 =item [Tags => ArrayRef[L<Paws::Proton::Tag>]]
853  
854  
855 =back
856  
857 Each argument is described in detail in: L<Paws::Proton::CreateEnvironmentTemplate>
858  
859 Returns: a L<Paws::Proton::CreateEnvironmentTemplateOutput> instance
860  
861 Create an environment template for AWS Proton. For more information,
862 see Environment Templates
863 (https://docs.aws.amazon.com/proton/latest/adminguide/ag-env-templates.html)
864 in the I<AWS Proton Administration Guide>.
865  
866 You can create an environment template in one of the two following
867 ways:
868  
869 =over
870  
871 =item *
872  
873 Register and publish a I<standard> environment template that instructs
874 AWS Proton to deploy and manage environment infrastructure.
875  
876 =item *
877  
878 Register and publish a I<customer managed> environment template that
879 connects AWS Proton to your existing provisioned infrastructure that
880 you manage. AWS Proton I<doesn't> manage your existing provisioned
881 infrastructure. To create an environment template for customer
882 provisioned and managed infrastructure, include the C<provisioning>
883 parameter and set the value to C<CUSTOMER_MANAGED>. For more
884 information, see Register and publish an environment template
885 (https://docs.aws.amazon.com/proton/latest/adminguide/env-template-v1.html)
886 in the I<AWS Proton Administration Guide>.
887  
888 =back
889  
890  
891  
892 =head2 CreateEnvironmentTemplateVersion
893  
894 =over
895  
896 =item Source => L<Paws::Proton::TemplateVersionSourceInput>
897  
898 =item TemplateName => Str
899  
900 =item [ClientToken => Str]
901  
902 =item [Description => Str]
903  
904 =item [MajorVersion => Str]
905  
906 =item [Tags => ArrayRef[L<Paws::Proton::Tag>]]
907  
908  
909 =back
910  
911 Each argument is described in detail in: L<Paws::Proton::CreateEnvironmentTemplateVersion>
912  
913 Returns: a L<Paws::Proton::CreateEnvironmentTemplateVersionOutput> instance
914  
915 Create a new major or minor version of an environment template. A major
916 version of an environment template is a version that I<isn't> backwards
917 compatible. A minor version of an environment template is a version
918 that's backwards compatible within its major version.
919  
920  
921 =head2 CreateService
922  
923 =over
924  
925 =item Name => Str
926  
927 =item Spec => Str
928  
929 =item TemplateMajorVersion => Str
930  
931 =item TemplateName => Str
932  
933 =item [BranchName => Str]
934  
935 =item [Description => Str]
936  
937 =item [RepositoryConnectionArn => Str]
938  
939 =item [RepositoryId => Str]
940  
941 =item [Tags => ArrayRef[L<Paws::Proton::Tag>]]
942  
943 =item [TemplateMinorVersion => Str]
944  
945  
946 =back
947  
948 Each argument is described in detail in: L<Paws::Proton::CreateService>
949  
950 Returns: a L<Paws::Proton::CreateServiceOutput> instance
951  
952 Create an AWS Proton service. An AWS Proton service is an instantiation
953 of a service template and often includes several service instances and
954 pipeline. For more information, see Services
955 (https://docs.aws.amazon.com/proton/latest/adminguide/ag-services.html)
956 in the I<AWS Proton Administration Guide> and Services
957 (https://docs.aws.amazon.com/proton/latest/userguide/ug-service.html)
958 in the I<AWS Proton User Guide>.
959  
960  
961 =head2 CreateServiceTemplate
962  
963 =over
964  
965 =item Name => Str
966  
967 =item [Description => Str]
968  
969 =item [DisplayName => Str]
970  
971 =item [EncryptionKey => Str]
972  
973 =item [PipelineProvisioning => Str]
974  
975 =item [Tags => ArrayRef[L<Paws::Proton::Tag>]]
976  
977  
978 =back
979  
980 Each argument is described in detail in: L<Paws::Proton::CreateServiceTemplate>
981  
982 Returns: a L<Paws::Proton::CreateServiceTemplateOutput> instance
983  
984 Create a service template. The administrator creates a service template
985 to define standardized infrastructure and an optional CICD service
986 pipeline. Developers, in turn, select the service template from AWS
987 Proton. If the selected service template includes a service pipeline
988 definition, they provide a link to their source code repository. AWS
989 Proton then deploys and manages the infrastructure defined by the
990 selected service template. For more information, see Service Templates
991 (https://docs.aws.amazon.com/proton/latest/adminguide/managing-svc-templates.html)
992 in the I<AWS Proton Administration Guide>.
993  
994  
995 =head2 CreateServiceTemplateVersion
996  
997 =over
998  
999 =item CompatibleEnvironmentTemplates => ArrayRef[L<Paws::Proton::CompatibleEnvironmentTemplateInput>]
1000  
1001 =item Source => L<Paws::Proton::TemplateVersionSourceInput>
1002  
1003 =item TemplateName => Str
1004  
1005 =item [ClientToken => Str]
1006  
1007 =item [Description => Str]
1008  
1009 =item [MajorVersion => Str]
1010  
1011 =item [Tags => ArrayRef[L<Paws::Proton::Tag>]]
1012  
1013  
1014 =back
1015  
1016 Each argument is described in detail in: L<Paws::Proton::CreateServiceTemplateVersion>
1017  
1018 Returns: a L<Paws::Proton::CreateServiceTemplateVersionOutput> instance
1019  
1020 Create a new major or minor version of a service template. A major
1021 version of a service template is a version that I<isn't> backwards
1022 compatible. A minor version of a service template is a version that's
1023 backwards compatible within its major version.
1024  
1025  
1026 =head2 DeleteEnvironment
1027  
1028 =over
1029  
1030 =item Name => Str
1031  
1032  
1033 =back
1034  
1035 Each argument is described in detail in: L<Paws::Proton::DeleteEnvironment>
1036  
1037 Returns: a L<Paws::Proton::DeleteEnvironmentOutput> instance
1038  
1039 Delete an environment.
1040  
1041  
1042 =head2 DeleteEnvironmentAccountConnection
1043  
1044 =over
1045  
1046 =item Id => Str
1047  
1048  
1049 =back
1050  
1051 Each argument is described in detail in: L<Paws::Proton::DeleteEnvironmentAccountConnection>
1052  
1053 Returns: a L<Paws::Proton::DeleteEnvironmentAccountConnectionOutput> instance
1054  
1055 In an environment account, delete an environment account connection.
1056  
1057 After you delete an environment account connection thatE<rsquo>s in use
1058 by an AWS Proton environment, AWS Proton I<canE<rsquo>t> manage the
1059 environment infrastructure resources until a new environment account
1060 connection is accepted for the environment account and associated
1061 environment. You're responsible for cleaning up provisioned resources
1062 that remain without an environment connection.
1063  
1064 For more information, see Environment account connections in the I<AWS
1065 Proton Administration guide>.
1066  
1067  
1068 =head2 DeleteEnvironmentTemplate
1069  
1070 =over
1071  
1072 =item Name => Str
1073  
1074  
1075 =back
1076  
1077 Each argument is described in detail in: L<Paws::Proton::DeleteEnvironmentTemplate>
1078  
1079 Returns: a L<Paws::Proton::DeleteEnvironmentTemplateOutput> instance
1080  
1081 If no other major or minor versions of an environment template exist,
1082 delete the environment template.
1083  
1084  
1085 =head2 DeleteEnvironmentTemplateVersion
1086  
1087 =over
1088  
1089 =item MajorVersion => Str
1090  
1091 =item MinorVersion => Str
1092  
1093 =item TemplateName => Str
1094  
1095  
1096 =back
1097  
1098 Each argument is described in detail in: L<Paws::Proton::DeleteEnvironmentTemplateVersion>
1099  
1100 Returns: a L<Paws::Proton::DeleteEnvironmentTemplateVersionOutput> instance
1101  
1102 If no other minor versions of an environment template exist, delete a
1103 major version of the environment template if it's not the
1104 C<Recommended> version. Delete the C<Recommended> version of the
1105 environment template if no other major versions or minor versions of
1106 the environment template exist. A major version of an environment
1107 template is a version that's not backwards compatible.
1108  
1109 Delete a minor version of an environment template if it I<isn't> the
1110 C<Recommended> version. Delete a C<Recommended> minor version of the
1111 environment template if no other minor versions of the environment
1112 template exist. A minor version of an environment template is a version
1113 that's backwards compatible.
1114  
1115  
1116 =head2 DeleteService
1117  
1118 =over
1119  
1120 =item Name => Str
1121  
1122  
1123 =back
1124  
1125 Each argument is described in detail in: L<Paws::Proton::DeleteService>
1126  
1127 Returns: a L<Paws::Proton::DeleteServiceOutput> instance
1128  
1129 Delete a service.
1130  
1131  
1132 =head2 DeleteServiceTemplate
1133  
1134 =over
1135  
1136 =item Name => Str
1137  
1138  
1139 =back
1140  
1141 Each argument is described in detail in: L<Paws::Proton::DeleteServiceTemplate>
1142  
1143 Returns: a L<Paws::Proton::DeleteServiceTemplateOutput> instance
1144  
1145 If no other major or minor versions of the service template exist,
1146 delete the service template.
1147  
1148  
1149 =head2 DeleteServiceTemplateVersion
1150  
1151 =over
1152  
1153 =item MajorVersion => Str
1154  
1155 =item MinorVersion => Str
1156  
1157 =item TemplateName => Str
1158  
1159  
1160 =back
1161  
1162 Each argument is described in detail in: L<Paws::Proton::DeleteServiceTemplateVersion>
1163  
1164 Returns: a L<Paws::Proton::DeleteServiceTemplateVersionOutput> instance
1165  
1166 If no other minor versions of a service template exist, delete a major
1167 version of the service template if it's not the C<Recommended> version.
1168 Delete the C<Recommended> version of the service template if no other
1169 major versions or minor versions of the service template exist. A major
1170 version of a service template is a version that I<isn't> backwards
1171 compatible.
1172  
1173 Delete a minor version of a service template if it's not the
1174 C<Recommended> version. Delete a C<Recommended> minor version of the
1175 service template if no other minor versions of the service template
1176 exist. A minor version of a service template is a version that's
1177 backwards compatible.
1178  
1179  
1180 =head2 GetAccountSettings
1181  
1182  
1183  
1184  
1185  
1186  
1187 Each argument is described in detail in: L<Paws::Proton::GetAccountSettings>
1188  
1189 Returns: a L<Paws::Proton::GetAccountSettingsOutput> instance
1190  
1191 Get detail data for the AWS Proton pipeline service role.
1192  
1193  
1194 =head2 GetEnvironment
1195  
1196 =over
1197  
1198 =item Name => Str
1199  
1200  
1201 =back
1202  
1203 Each argument is described in detail in: L<Paws::Proton::GetEnvironment>
1204  
1205 Returns: a L<Paws::Proton::GetEnvironmentOutput> instance
1206  
1207 Get detail data for an environment.
1208  
1209  
1210 =head2 GetEnvironmentAccountConnection
1211  
1212 =over
1213  
1214 =item Id => Str
1215  
1216  
1217 =back
1218  
1219 Each argument is described in detail in: L<Paws::Proton::GetEnvironmentAccountConnection>
1220  
1221 Returns: a L<Paws::Proton::GetEnvironmentAccountConnectionOutput> instance
1222  
1223 In an environment account, view the detail data for an environment
1224 account connection.
1225  
1226 For more information, see Environment account connections in the I<AWS
1227 Proton Administration guide>.
1228  
1229  
1230 =head2 GetEnvironmentTemplate
1231  
1232 =over
1233  
1234 =item Name => Str
1235  
1236  
1237 =back
1238  
1239 Each argument is described in detail in: L<Paws::Proton::GetEnvironmentTemplate>
1240  
1241 Returns: a L<Paws::Proton::GetEnvironmentTemplateOutput> instance
1242  
1243 Get detail data for an environment template.
1244  
1245  
1246 =head2 GetEnvironmentTemplateVersion
1247  
1248 =over
1249  
1250 =item MajorVersion => Str
1251  
1252 =item MinorVersion => Str
1253  
1254 =item TemplateName => Str
1255  
1256  
1257 =back
1258  
1259 Each argument is described in detail in: L<Paws::Proton::GetEnvironmentTemplateVersion>
1260  
1261 Returns: a L<Paws::Proton::GetEnvironmentTemplateVersionOutput> instance
1262  
1263 View detail data for a major or minor version of an environment
1264 template.
1265  
1266  
1267 =head2 GetService
1268  
1269 =over
1270  
1271 =item Name => Str
1272  
1273  
1274 =back
1275  
1276 Each argument is described in detail in: L<Paws::Proton::GetService>
1277  
1278 Returns: a L<Paws::Proton::GetServiceOutput> instance
1279  
1280 Get detail data for a service.
1281  
1282  
1283 =head2 GetServiceInstance
1284  
1285 =over
1286  
1287 =item Name => Str
1288  
1289 =item ServiceName => Str
1290  
1291  
1292 =back
1293  
1294 Each argument is described in detail in: L<Paws::Proton::GetServiceInstance>
1295  
1296 Returns: a L<Paws::Proton::GetServiceInstanceOutput> instance
1297  
1298 Get detail data for a service instance. A service instance is an
1299 instantiation of service template, which is running in a specific
1300 environment.
1301  
1302  
1303 =head2 GetServiceTemplate
1304  
1305 =over
1306  
1307 =item Name => Str
1308  
1309  
1310 =back
1311  
1312 Each argument is described in detail in: L<Paws::Proton::GetServiceTemplate>
1313  
1314 Returns: a L<Paws::Proton::GetServiceTemplateOutput> instance
1315  
1316 Get detail data for a service template.
1317  
1318  
1319 =head2 GetServiceTemplateVersion
1320  
1321 =over
1322  
1323 =item MajorVersion => Str
1324  
1325 =item MinorVersion => Str
1326  
1327 =item TemplateName => Str
1328  
1329  
1330 =back
1331  
1332 Each argument is described in detail in: L<Paws::Proton::GetServiceTemplateVersion>
1333  
1334 Returns: a L<Paws::Proton::GetServiceTemplateVersionOutput> instance
1335  
1336 View detail data for a major or minor version of a service template.
1337  
1338  
1339 =head2 ListEnvironmentAccountConnections
1340  
1341 =over
1342  
1343 =item RequestedBy => Str
1344  
1345 =item [EnvironmentName => Str]
1346  
1347 =item [MaxResults => Int]
1348  
1349 =item [NextToken => Str]
1350  
1351 =item [Statuses => ArrayRef[Str|Undef]]
1352  
1353  
1354 =back
1355  
1356 Each argument is described in detail in: L<Paws::Proton::ListEnvironmentAccountConnections>
1357  
1358 Returns: a L<Paws::Proton::ListEnvironmentAccountConnectionsOutput> instance
1359  
1360 View a list of environment account connections.
1361  
1362 For more information, see Environment account connections in the I<AWS
1363 Proton Administration guide>.
1364  
1365  
1366 =head2 ListEnvironments
1367  
1368 =over
1369  
1370 =item [EnvironmentTemplates => ArrayRef[L<Paws::Proton::EnvironmentTemplateFilter>]]
1371  
1372 =item [MaxResults => Int]
1373  
1374 =item [NextToken => Str]
1375  
1376  
1377 =back
1378  
1379 Each argument is described in detail in: L<Paws::Proton::ListEnvironments>
1380  
1381 Returns: a L<Paws::Proton::ListEnvironmentsOutput> instance
1382  
1383 List environments with detail data summaries.
1384  
1385  
1386 =head2 ListEnvironmentTemplates
1387  
1388 =over
1389  
1390 =item [MaxResults => Int]
1391  
1392 =item [NextToken => Str]
1393  
1394  
1395 =back
1396  
1397 Each argument is described in detail in: L<Paws::Proton::ListEnvironmentTemplates>
1398  
1399 Returns: a L<Paws::Proton::ListEnvironmentTemplatesOutput> instance
1400  
1401 List environment templates.
1402  
1403  
1404 =head2 ListEnvironmentTemplateVersions
1405  
1406 =over
1407  
1408 =item TemplateName => Str
1409  
1410 =item [MajorVersion => Str]
1411  
1412 =item [MaxResults => Int]
1413  
1414 =item [NextToken => Str]
1415  
1416  
1417 =back
1418  
1419 Each argument is described in detail in: L<Paws::Proton::ListEnvironmentTemplateVersions>
1420  
1421 Returns: a L<Paws::Proton::ListEnvironmentTemplateVersionsOutput> instance
1422  
1423 List major or minor versions of an environment template with detail
1424 data.
1425  
1426  
1427 =head2 ListServiceInstances
1428  
1429 =over
1430  
1431 =item [MaxResults => Int]
1432  
1433 =item [NextToken => Str]
1434  
1435 =item [ServiceName => Str]
1436  
1437  
1438 =back
1439  
1440 Each argument is described in detail in: L<Paws::Proton::ListServiceInstances>
1441  
1442 Returns: a L<Paws::Proton::ListServiceInstancesOutput> instance
1443  
1444 List service instances with summaries of detail data.
1445  
1446  
1447 =head2 ListServices
1448  
1449 =over
1450  
1451 =item [MaxResults => Int]
1452  
1453 =item [NextToken => Str]
1454  
1455  
1456 =back
1457  
1458 Each argument is described in detail in: L<Paws::Proton::ListServices>
1459  
1460 Returns: a L<Paws::Proton::ListServicesOutput> instance
1461  
1462 List services with summaries of detail data.
1463  
1464  
1465 =head2 ListServiceTemplates
1466  
1467 =over
1468  
1469 =item [MaxResults => Int]
1470  
1471 =item [NextToken => Str]
1472  
1473  
1474 =back
1475  
1476 Each argument is described in detail in: L<Paws::Proton::ListServiceTemplates>
1477  
1478 Returns: a L<Paws::Proton::ListServiceTemplatesOutput> instance
1479  
1480 List service templates with detail data.
1481  
1482  
1483 =head2 ListServiceTemplateVersions
1484  
1485 =over
1486  
1487 =item TemplateName => Str
1488  
1489 =item [MajorVersion => Str]
1490  
1491 =item [MaxResults => Int]
1492  
1493 =item [NextToken => Str]
1494  
1495  
1496 =back
1497  
1498 Each argument is described in detail in: L<Paws::Proton::ListServiceTemplateVersions>
1499  
1500 Returns: a L<Paws::Proton::ListServiceTemplateVersionsOutput> instance
1501  
1502 List major or minor versions of a service template with detail data.
1503  
1504  
1505 =head2 ListTagsForResource
1506  
1507 =over
1508  
1509 =item ResourceArn => Str
1510  
1511 =item [MaxResults => Int]
1512  
1513 =item [NextToken => Str]
1514  
1515  
1516 =back
1517  
1518 Each argument is described in detail in: L<Paws::Proton::ListTagsForResource>
1519  
1520 Returns: a L<Paws::Proton::ListTagsForResourceOutput> instance
1521  
1522 List tags for a resource. For more information, see I<AWS Proton
1523 resources and tagging> in the AWS Proton Administration Guide
1524 (https://docs.aws.amazon.com/proton/latest/adminguide/resources.html)
1525 or AWS Proton User Guide
1526 (https://docs.aws.amazon.com/proton/latest/userguide/resources.html).
1527  
1528  
1529 =head2 RejectEnvironmentAccountConnection
1530  
1531 =over
1532  
1533 =item Id => Str
1534  
1535  
1536 =back
1537  
1538 Each argument is described in detail in: L<Paws::Proton::RejectEnvironmentAccountConnection>
1539  
1540 Returns: a L<Paws::Proton::RejectEnvironmentAccountConnectionOutput> instance
1541  
1542 In a management account, reject an environment account connection from
1543 another environment account.
1544  
1545 After you reject an environment account connection request, you
1546 I<wonE<rsquo>t> be able to accept or use the rejected environment
1547 account connection.
1548  
1549 You I<canE<rsquo>t> reject an environment account connection that is
1550 connected to an environment.
1551  
1552 For more information, see Environment account connections in the I<AWS
1553 Proton Administration guide>.
1554  
1555  
1556 =head2 TagResource
1557  
1558 =over
1559  
1560 =item ResourceArn => Str
1561  
1562 =item Tags => ArrayRef[L<Paws::Proton::Tag>]
1563  
1564  
1565 =back
1566  
1567 Each argument is described in detail in: L<Paws::Proton::TagResource>
1568  
1569 Returns: a L<Paws::Proton::TagResourceOutput> instance
1570  
1571 Tag a resource. For more information, see I<AWS Proton resources and
1572 tagging> in the AWS Proton Administration Guide
1573 (https://docs.aws.amazon.com/proton/latest/adminguide/resources.html)
1574 or AWS Proton User Guide
1575 (https://docs.aws.amazon.com/proton/latest/userguide/resources.html).
1576  
1577  
1578 =head2 UntagResource
1579  
1580 =over
1581  
1582 =item ResourceArn => Str
1583  
1584 =item TagKeys => ArrayRef[Str|Undef]
1585  
1586  
1587 =back
1588  
1589 Each argument is described in detail in: L<Paws::Proton::UntagResource>
1590  
1591 Returns: a L<Paws::Proton::UntagResourceOutput> instance
1592  
1593 Remove a tag from a resource. For more information, see I<AWS Proton
1594 resources and tagging> in the AWS Proton Administration Guide
1595 (https://docs.aws.amazon.com/proton/latest/adminguide/resources.html)
1596 or AWS Proton User Guide
1597 (https://docs.aws.amazon.com/proton/latest/userguide/resources.html).
1598  
1599  
1600 =head2 UpdateAccountSettings
1601  
1602 =over
1603  
1604 =item [PipelineServiceRoleArn => Str]
1605  
1606  
1607 =back
1608  
1609 Each argument is described in detail in: L<Paws::Proton::UpdateAccountSettings>
1610  
1611 Returns: a L<Paws::Proton::UpdateAccountSettingsOutput> instance
1612  
1613 Update the AWS Proton pipeline service account settings.
1614  
1615  
1616 =head2 UpdateEnvironment
1617  
1618 =over
1619  
1620 =item DeploymentType => Str
1621  
1622 =item Name => Str
1623  
1624 =item [Description => Str]
1625  
1626 =item [EnvironmentAccountConnectionId => Str]
1627  
1628 =item [ProtonServiceRoleArn => Str]
1629  
1630 =item [Spec => Str]
1631  
1632 =item [TemplateMajorVersion => Str]
1633  
1634 =item [TemplateMinorVersion => Str]
1635  
1636  
1637 =back
1638  
1639 Each argument is described in detail in: L<Paws::Proton::UpdateEnvironment>
1640  
1641 Returns: a L<Paws::Proton::UpdateEnvironmentOutput> instance
1642  
1643 Update an environment.
1644  
1645 If the environment is associated with an environment account
1646 connection, I<don't> update or include the C<protonServiceRoleArn>
1647 parameter to update or connect to an environment account connection.
1648  
1649 You can only update to a new environment account connection if it was
1650 created in the same environment account that the current environment
1651 account connection was created in and associated with the current
1652 environment.
1653  
1654 If the environment I<isn't> associated with an environment account
1655 connection, I<don't> update or include the
1656 C<environmentAccountConnectionId> parameter to update or connect to an
1657 environment account connection.
1658  
1659 You can update either the C<environmentAccountConnectionId> or
1660 C<protonServiceRoleArn> parameter and value. You canE<rsquo>t update
1661 both.
1662  
1663 There are four modes for updating an environment as described in the
1664 following. The C<deploymentType> field defines the mode.
1665  
1666 =over
1667  
1668 =item C<NONE>
1669  
1670 In this mode, a deployment I<doesn't> occur. Only the requested
1671 metadata parameters are updated.
1672  
1673 =item C<CURRENT_VERSION>
1674  
1675 In this mode, the environment is deployed and updated with the new spec
1676 that you provide. Only requested parameters are updated.
1677 I<DonE<rsquo>t> include minor or major version parameters when you use
1678 this C<deployment-type>.
1679  
1680 =item C<MINOR_VERSION>
1681  
1682 In this mode, the environment is deployed and updated with the
1683 published, recommended (latest) minor version of the current major
1684 version in use, by default. You can also specify a different minor
1685 version of the current major version in use.
1686  
1687 =item C<MAJOR_VERSION>
1688  
1689 In this mode, the environment is deployed and updated with the
1690 published, recommended (latest) major and minor version of the current
1691 template, by default. You can also specify a different major version
1692 that's higher than the major version in use and a minor version
1693 (optional).
1694  
1695 =back
1696  
1697  
1698  
1699 =head2 UpdateEnvironmentAccountConnection
1700  
1701 =over
1702  
1703 =item Id => Str
1704  
1705 =item RoleArn => Str
1706  
1707  
1708 =back
1709  
1710 Each argument is described in detail in: L<Paws::Proton::UpdateEnvironmentAccountConnection>
1711  
1712 Returns: a L<Paws::Proton::UpdateEnvironmentAccountConnectionOutput> instance
1713  
1714 In an environment account, update an environment account connection to
1715 use a new IAM role.
1716  
1717 For more information, see Environment account connections in the I<AWS
1718 Proton Administration guide>.
1719  
1720  
1721 =head2 UpdateEnvironmentTemplate
1722  
1723 =over
1724  
1725 =item Name => Str
1726  
1727 =item [Description => Str]
1728  
1729 =item [DisplayName => Str]
1730  
1731  
1732 =back
1733  
1734 Each argument is described in detail in: L<Paws::Proton::UpdateEnvironmentTemplate>
1735  
1736 Returns: a L<Paws::Proton::UpdateEnvironmentTemplateOutput> instance
1737  
1738 Update an environment template.
1739  
1740  
1741 =head2 UpdateEnvironmentTemplateVersion
1742  
1743 =over
1744  
1745 =item MajorVersion => Str
1746  
1747 =item MinorVersion => Str
1748  
1749 =item TemplateName => Str
1750  
1751 =item [Description => Str]
1752  
1753 =item [Status => Str]
1754  
1755  
1756 =back
1757  
1758 Each argument is described in detail in: L<Paws::Proton::UpdateEnvironmentTemplateVersion>
1759  
1760 Returns: a L<Paws::Proton::UpdateEnvironmentTemplateVersionOutput> instance
1761  
1762 Update a major or minor version of an environment template.
1763  
1764  
1765 =head2 UpdateService
1766  
1767 =over
1768  
1769 =item Name => Str
1770  
1771 =item [Description => Str]
1772  
1773 =item [Spec => Str]
1774  
1775  
1776 =back
1777  
1778 Each argument is described in detail in: L<Paws::Proton::UpdateService>
1779  
1780 Returns: a L<Paws::Proton::UpdateServiceOutput> instance
1781  
1782 Edit a service description or use a spec to add and delete service
1783 instances.
1784  
1785 Existing service instances and the service pipeline I<can't> be edited
1786 using this API. They can only be deleted.
1787  
1788 Use the C<description> parameter to modify the description.
1789  
1790 Edit the C<spec> parameter to add or delete instances.
1791  
1792  
1793 =head2 UpdateServiceInstance
1794  
1795 =over
1796  
1797 =item DeploymentType => Str
1798  
1799 =item Name => Str
1800  
1801 =item ServiceName => Str
1802  
1803 =item [Spec => Str]
1804  
1805 =item [TemplateMajorVersion => Str]
1806  
1807 =item [TemplateMinorVersion => Str]
1808  
1809  
1810 =back
1811  
1812 Each argument is described in detail in: L<Paws::Proton::UpdateServiceInstance>
1813  
1814 Returns: a L<Paws::Proton::UpdateServiceInstanceOutput> instance
1815  
1816 Update a service instance.
1817  
1818 There are four modes for updating a service instance as described in
1819 the following. The C<deploymentType> field defines the mode.
1820  
1821 =over
1822  
1823 =item C<NONE>
1824  
1825 In this mode, a deployment I<doesn't> occur. Only the requested
1826 metadata parameters are updated.
1827  
1828 =item C<CURRENT_VERSION>
1829  
1830 In this mode, the service instance is deployed and updated with the new
1831 spec that you provide. Only requested parameters are updated.
1832 I<DonE<rsquo>t> include minor or major version parameters when you use
1833 this C<deployment-type>.
1834  
1835 =item C<MINOR_VERSION>
1836  
1837 In this mode, the service instance is deployed and updated with the
1838 published, recommended (latest) minor version of the current major
1839 version in use, by default. You can also specify a different minor
1840 version of the current major version in use.
1841  
1842 =item C<MAJOR_VERSION>
1843  
1844 In this mode, the service instance is deployed and updated with the
1845 published, recommended (latest) major and minor version of the current
1846 template, by default. You can also specify a different major version
1847 that is higher than the major version in use and a minor version
1848 (optional).
1849  
1850 =back
1851  
1852  
1853  
1854 =head2 UpdateServicePipeline
1855  
1856 =over
1857  
1858 =item DeploymentType => Str
1859  
1860 =item ServiceName => Str
1861  
1862 =item Spec => Str
1863  
1864 =item [TemplateMajorVersion => Str]
1865  
1866 =item [TemplateMinorVersion => Str]
1867  
1868  
1869 =back
1870  
1871 Each argument is described in detail in: L<Paws::Proton::UpdateServicePipeline>
1872  
1873 Returns: a L<Paws::Proton::UpdateServicePipelineOutput> instance
1874  
1875 Update the service pipeline.
1876  
1877 There are four modes for updating a service pipeline as described in
1878 the following. The C<deploymentType> field defines the mode.
1879  
1880 =over
1881  
1882 =item C<NONE>
1883  
1884 In this mode, a deployment I<doesn't> occur. Only the requested
1885 metadata parameters are updated.
1886  
1887 =item C<CURRENT_VERSION>
1888  
1889 In this mode, the service pipeline is deployed and updated with the new
1890 spec that you provide. Only requested parameters are updated.
1891 I<DonE<rsquo>t> include minor or major version parameters when you use
1892 this C<deployment-type>.
1893  
1894 =item C<MINOR_VERSION>
1895  
1896 In this mode, the service pipeline is deployed and updated with the
1897 published, recommended (latest) minor version of the current major
1898 version in use, by default. You can also specify a different minor
1899 version of the current major version in use.
1900  
1901 =item C<MAJOR_VERSION>
1902  
1903 In this mode, the service pipeline is deployed and updated with the
1904 published, recommended (latest) major and minor version of the current
1905 template by default. You can also specify a different major version
1906 that is higher than the major version in use and a minor version
1907 (optional).
1908  
1909 =back
1910  
1911  
1912  
1913 =head2 UpdateServiceTemplate
1914  
1915 =over
1916  
1917 =item Name => Str
1918  
1919 =item [Description => Str]
1920  
1921 =item [DisplayName => Str]
1922  
1923  
1924 =back
1925  
1926 Each argument is described in detail in: L<Paws::Proton::UpdateServiceTemplate>
1927  
1928 Returns: a L<Paws::Proton::UpdateServiceTemplateOutput> instance
1929  
1930 Update a service template.
1931  
1932  
1933 =head2 UpdateServiceTemplateVersion
1934  
1935 =over
1936  
1937 =item MajorVersion => Str
1938  
1939 =item MinorVersion => Str
1940  
1941 =item TemplateName => Str
1942  
1943 =item [CompatibleEnvironmentTemplates => ArrayRef[L<Paws::Proton::CompatibleEnvironmentTemplateInput>]]
1944  
1945 =item [Description => Str]
1946  
1947 =item [Status => Str]
1948  
1949  
1950 =back
1951  
1952 Each argument is described in detail in: L<Paws::Proton::UpdateServiceTemplateVersion>
1953  
1954 Returns: a L<Paws::Proton::UpdateServiceTemplateVersionOutput> instance
1955  
1956 Update a major or minor version of a service template.
1957  
1958  
1959  
1960  
1961 =head1 PAGINATORS
1962  
1963 Paginator methods are helpers that repetively call methods that return partial results
1964  
1965 =head2 ListAllEnvironmentAccountConnections(sub { },RequestedBy => Str, [EnvironmentName => Str, MaxResults => Int, NextToken => Str, Statuses => ArrayRef[Str|Undef]])
1966  
1967 =head2 ListAllEnvironmentAccountConnections(RequestedBy => Str, [EnvironmentName => Str, MaxResults => Int, NextToken => Str, Statuses => ArrayRef[Str|Undef]])
1968  
1969  
1970 If passed a sub as first parameter, it will call the sub for each element found in :
1971  
1972 - environmentAccountConnections, passing the object as the first parameter, and the string 'environmentAccountConnections' as the second parameter
1973  
1974 If not, it will return a a L<Paws::Proton::ListEnvironmentAccountConnectionsOutput> 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.
1975  
1976  
1977 =head2 ListAllEnvironments(sub { },[EnvironmentTemplates => ArrayRef[L<Paws::Proton::EnvironmentTemplateFilter>], MaxResults => Int, NextToken => Str])
1978  
1979 =head2 ListAllEnvironments([EnvironmentTemplates => ArrayRef[L<Paws::Proton::EnvironmentTemplateFilter>], MaxResults => Int, NextToken => Str])
1980  
1981  
1982 If passed a sub as first parameter, it will call the sub for each element found in :
1983  
1984 - environments, passing the object as the first parameter, and the string 'environments' as the second parameter
1985  
1986 If not, it will return a a L<Paws::Proton::ListEnvironmentsOutput> 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.
1987  
1988  
1989 =head2 ListAllEnvironmentTemplates(sub { },[MaxResults => Int, NextToken => Str])
1990  
1991 =head2 ListAllEnvironmentTemplates([MaxResults => Int, NextToken => Str])
1992  
1993  
1994 If passed a sub as first parameter, it will call the sub for each element found in :
1995  
1996 - templates, passing the object as the first parameter, and the string 'templates' as the second parameter
1997  
1998 If not, it will return a a L<Paws::Proton::ListEnvironmentTemplatesOutput> 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.
1999  
2000  
2001 =head2 ListAllEnvironmentTemplateVersions(sub { },TemplateName => Str, [MajorVersion => Str, MaxResults => Int, NextToken => Str])
2002  
2003 =head2 ListAllEnvironmentTemplateVersions(TemplateName => Str, [MajorVersion => Str, MaxResults => Int, NextToken => Str])
2004  
2005  
2006 If passed a sub as first parameter, it will call the sub for each element found in :
2007  
2008 - templateVersions, passing the object as the first parameter, and the string 'templateVersions' as the second parameter
2009  
2010 If not, it will return a a L<Paws::Proton::ListEnvironmentTemplateVersionsOutput> 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.
2011  
2012  
2013 =head2 ListAllServiceInstances(sub { },[MaxResults => Int, NextToken => Str, ServiceName => Str])
2014  
2015 =head2 ListAllServiceInstances([MaxResults => Int, NextToken => Str, ServiceName => Str])
2016  
2017  
2018 If passed a sub as first parameter, it will call the sub for each element found in :
2019  
2020 - serviceInstances, passing the object as the first parameter, and the string 'serviceInstances' as the second parameter
2021  
2022 If not, it will return a a L<Paws::Proton::ListServiceInstancesOutput> 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.
2023  
2024  
2025 =head2 ListAllServices(sub { },[MaxResults => Int, NextToken => Str])
2026  
2027 =head2 ListAllServices([MaxResults => Int, NextToken => Str])
2028  
2029  
2030 If passed a sub as first parameter, it will call the sub for each element found in :
2031  
2032 - services, passing the object as the first parameter, and the string 'services' as the second parameter
2033  
2034 If not, it will return a a L<Paws::Proton::ListServicesOutput> 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.
2035  
2036  
2037 =head2 ListAllServiceTemplates(sub { },[MaxResults => Int, NextToken => Str])
2038  
2039 =head2 ListAllServiceTemplates([MaxResults => Int, NextToken => Str])
2040  
2041  
2042 If passed a sub as first parameter, it will call the sub for each element found in :
2043  
2044 - templates, passing the object as the first parameter, and the string 'templates' as the second parameter
2045  
2046 If not, it will return a a L<Paws::Proton::ListServiceTemplatesOutput> 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.
2047  
2048  
2049 =head2 ListAllServiceTemplateVersions(sub { },TemplateName => Str, [MajorVersion => Str, MaxResults => Int, NextToken => Str])
2050  
2051 =head2 ListAllServiceTemplateVersions(TemplateName => Str, [MajorVersion => Str, MaxResults => Int, NextToken => Str])
2052  
2053  
2054 If passed a sub as first parameter, it will call the sub for each element found in :
2055  
2056 - templateVersions, passing the object as the first parameter, and the string 'templateVersions' as the second parameter
2057  
2058 If not, it will return a a L<Paws::Proton::ListServiceTemplateVersionsOutput> 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.
2059  
2060  
2061 =head2 ListAllTagsForResource(sub { },ResourceArn => Str, [MaxResults => Int, NextToken => Str])
2062  
2063 =head2 ListAllTagsForResource(ResourceArn => Str, [MaxResults => Int, NextToken => Str])
2064  
2065  
2066 If passed a sub as first parameter, it will call the sub for each element found in :
2067  
2068 - tags, passing the object as the first parameter, and the string 'tags' as the second parameter
2069  
2070 If not, it will return a a L<Paws::Proton::ListTagsForResourceOutput> 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.
2071  
2072  
2073  
2074  
2075  
2076 =head1 SEE ALSO
2077  
2078 This service class forms part of L<Paws>
2079  
2080 =head1 BUGS and CONTRIBUTIONS
2081  
2082 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
2083  
2084 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
2085  
2086 =cut
2087