rusoto_codepipeline/
generated.rs

1// =================================================================
2//
3//                           * WARNING *
4//
5//                    This file is generated!
6//
7//  Changes made to this file will be overwritten. If changes are
8//  required to the generated code, the service_crategen project
9//  must be updated to generate the changes.
10//
11// =================================================================
12
13use std::error::Error;
14use std::fmt;
15
16use async_trait::async_trait;
17use rusoto_core::credential::ProvideAwsCredentials;
18use rusoto_core::region;
19use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
20use rusoto_core::{Client, RusotoError};
21
22use rusoto_core::proto;
23use rusoto_core::request::HttpResponse;
24use rusoto_core::signature::SignedRequest;
25#[allow(unused_imports)]
26use serde::{Deserialize, Serialize};
27
28impl CodePipelineClient {
29    fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
30        let mut request =
31            SignedRequest::new(http_method, "codepipeline", &self.region, request_uri);
32
33        request.set_content_type("application/x-amz-json-1.1".to_owned());
34
35        request
36    }
37
38    async fn sign_and_dispatch<E>(
39        &self,
40        request: SignedRequest,
41        from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
42    ) -> Result<HttpResponse, RusotoError<E>> {
43        let mut response = self.client.sign_and_dispatch(request).await?;
44        if !response.status.is_success() {
45            let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
46            return Err(from_response(response));
47        }
48
49        Ok(response)
50    }
51}
52
53use serde_json;
54/// <p>Represents an AWS session credentials object. These credentials are temporary credentials that are issued by AWS Secure Token Service (STS). They can be used to access input and output artifacts in the S3 bucket used to store artifact for the pipeline in AWS CodePipeline.</p>
55#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
56#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
57pub struct AWSSessionCredentials {
58    /// <p>The access key for the session.</p>
59    #[serde(rename = "accessKeyId")]
60    pub access_key_id: String,
61    /// <p>The secret access key for the session.</p>
62    #[serde(rename = "secretAccessKey")]
63    pub secret_access_key: String,
64    /// <p>The token for the session.</p>
65    #[serde(rename = "sessionToken")]
66    pub session_token: String,
67}
68
69/// <p>Represents the input of an AcknowledgeJob action.</p>
70#[derive(Clone, Debug, Default, PartialEq, Serialize)]
71#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
72pub struct AcknowledgeJobInput {
73    /// <p>The unique system-generated ID of the job for which you want to confirm receipt.</p>
74    #[serde(rename = "jobId")]
75    pub job_id: String,
76    /// <p>A system-generated random number that AWS CodePipeline uses to ensure that the job is being worked on by only one job worker. Get this number from the response of the <a>PollForJobs</a> request that returned this job.</p>
77    #[serde(rename = "nonce")]
78    pub nonce: String,
79}
80
81/// <p>Represents the output of an AcknowledgeJob action.</p>
82#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
83#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
84pub struct AcknowledgeJobOutput {
85    /// <p>Whether the job worker has received the specified job.</p>
86    #[serde(rename = "status")]
87    #[serde(skip_serializing_if = "Option::is_none")]
88    pub status: Option<String>,
89}
90
91/// <p>Represents the input of an AcknowledgeThirdPartyJob action.</p>
92#[derive(Clone, Debug, Default, PartialEq, Serialize)]
93#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
94pub struct AcknowledgeThirdPartyJobInput {
95    /// <p>The clientToken portion of the clientId and clientToken pair used to verify that the calling entity is allowed access to the job and its details.</p>
96    #[serde(rename = "clientToken")]
97    pub client_token: String,
98    /// <p>The unique system-generated ID of the job.</p>
99    #[serde(rename = "jobId")]
100    pub job_id: String,
101    /// <p>A system-generated random number that AWS CodePipeline uses to ensure that the job is being worked on by only one job worker. Get this number from the response to a <a>GetThirdPartyJobDetails</a> request.</p>
102    #[serde(rename = "nonce")]
103    pub nonce: String,
104}
105
106/// <p>Represents the output of an AcknowledgeThirdPartyJob action.</p>
107#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
108#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
109pub struct AcknowledgeThirdPartyJobOutput {
110    /// <p>The status information for the third party job, if any.</p>
111    #[serde(rename = "status")]
112    #[serde(skip_serializing_if = "Option::is_none")]
113    pub status: Option<String>,
114}
115
116/// <p>Represents information about an action configuration.</p>
117#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
118#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
119pub struct ActionConfiguration {
120    /// <p>The configuration data for the action.</p>
121    #[serde(rename = "configuration")]
122    #[serde(skip_serializing_if = "Option::is_none")]
123    pub configuration: Option<::std::collections::HashMap<String, String>>,
124}
125
126/// <p>Represents information about an action configuration property.</p>
127#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
128pub struct ActionConfigurationProperty {
129    /// <p>The description of the action configuration property that is displayed to users.</p>
130    #[serde(rename = "description")]
131    #[serde(skip_serializing_if = "Option::is_none")]
132    pub description: Option<String>,
133    /// <p>Whether the configuration property is a key.</p>
134    #[serde(rename = "key")]
135    pub key: bool,
136    /// <p>The name of the action configuration property.</p>
137    #[serde(rename = "name")]
138    pub name: String,
139    /// <p>Indicates that the property is used with <code>PollForJobs</code>. When creating a custom action, an action can have up to one queryable property. If it has one, that property must be both required and not secret.</p> <p>If you create a pipeline with a custom action type, and that custom action contains a queryable property, the value for that configuration property is subject to other restrictions. The value must be less than or equal to twenty (20) characters. The value can contain only alphanumeric characters, underscores, and hyphens.</p>
140    #[serde(rename = "queryable")]
141    #[serde(skip_serializing_if = "Option::is_none")]
142    pub queryable: Option<bool>,
143    /// <p>Whether the configuration property is a required value.</p>
144    #[serde(rename = "required")]
145    pub required: bool,
146    /// <p>Whether the configuration property is secret. Secrets are hidden from all calls except for <code>GetJobDetails</code>, <code>GetThirdPartyJobDetails</code>, <code>PollForJobs</code>, and <code>PollForThirdPartyJobs</code>.</p> <p>When updating a pipeline, passing * * * * * without changing any other values of the action preserves the previous value of the secret.</p>
147    #[serde(rename = "secret")]
148    pub secret: bool,
149    /// <p>The type of the configuration property.</p>
150    #[serde(rename = "type")]
151    #[serde(skip_serializing_if = "Option::is_none")]
152    pub type_: Option<String>,
153}
154
155/// <p>Represents the context of an action in the stage of a pipeline to a job worker.</p>
156#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
157#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
158pub struct ActionContext {
159    /// <p>The system-generated unique ID that corresponds to an action's execution.</p>
160    #[serde(rename = "actionExecutionId")]
161    #[serde(skip_serializing_if = "Option::is_none")]
162    pub action_execution_id: Option<String>,
163    /// <p>The name of the action in the context of a job.</p>
164    #[serde(rename = "name")]
165    #[serde(skip_serializing_if = "Option::is_none")]
166    pub name: Option<String>,
167}
168
169/// <p>Represents information about an action declaration.</p>
170#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
171pub struct ActionDeclaration {
172    /// <p>Specifies the action type and the provider of the action.</p>
173    #[serde(rename = "actionTypeId")]
174    pub action_type_id: ActionTypeId,
175    /// <p>The action's configuration. These are key-value pairs that specify input values for an action. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements">Action Structure Requirements in CodePipeline</a>. For the list of configuration properties for the AWS CloudFormation action type in CodePipeline, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html">Configuration Properties Reference</a> in the <i>AWS CloudFormation User Guide</i>. For template snippets with examples, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html">Using Parameter Override Functions with CodePipeline Pipelines</a> in the <i>AWS CloudFormation User Guide</i>.</p> <p>The values can be represented in either JSON or YAML format. For example, the JSON configuration item format is as follows: </p> <p> <i>JSON:</i> </p> <p> <code>"Configuration" : { Key : Value },</code> </p>
176    #[serde(rename = "configuration")]
177    #[serde(skip_serializing_if = "Option::is_none")]
178    pub configuration: Option<::std::collections::HashMap<String, String>>,
179    /// <p>The name or ID of the artifact consumed by the action, such as a test or build artifact.</p>
180    #[serde(rename = "inputArtifacts")]
181    #[serde(skip_serializing_if = "Option::is_none")]
182    pub input_artifacts: Option<Vec<InputArtifact>>,
183    /// <p>The action declaration's name.</p>
184    #[serde(rename = "name")]
185    pub name: String,
186    /// <p>The variable namespace associated with the action. All variables produced as output by this action fall under this namespace.</p>
187    #[serde(rename = "namespace")]
188    #[serde(skip_serializing_if = "Option::is_none")]
189    pub namespace: Option<String>,
190    /// <p>The name or ID of the result of the action declaration, such as a test or build artifact.</p>
191    #[serde(rename = "outputArtifacts")]
192    #[serde(skip_serializing_if = "Option::is_none")]
193    pub output_artifacts: Option<Vec<OutputArtifact>>,
194    /// <p>The action declaration's AWS Region, such as us-east-1.</p>
195    #[serde(rename = "region")]
196    #[serde(skip_serializing_if = "Option::is_none")]
197    pub region: Option<String>,
198    /// <p>The ARN of the IAM service role that performs the declared action. This is assumed through the roleArn for the pipeline.</p>
199    #[serde(rename = "roleArn")]
200    #[serde(skip_serializing_if = "Option::is_none")]
201    pub role_arn: Option<String>,
202    /// <p>The order in which actions are run.</p>
203    #[serde(rename = "runOrder")]
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub run_order: Option<i64>,
206}
207
208/// <p>Represents information about the run of an action.</p>
209#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
210#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
211pub struct ActionExecution {
212    /// <p>The details of an error returned by a URL external to AWS.</p>
213    #[serde(rename = "errorDetails")]
214    #[serde(skip_serializing_if = "Option::is_none")]
215    pub error_details: Option<ErrorDetails>,
216    /// <p>The external ID of the run of the action.</p>
217    #[serde(rename = "externalExecutionId")]
218    #[serde(skip_serializing_if = "Option::is_none")]
219    pub external_execution_id: Option<String>,
220    /// <p>The URL of a resource external to AWS that is used when running the action (for example, an external repository URL).</p>
221    #[serde(rename = "externalExecutionUrl")]
222    #[serde(skip_serializing_if = "Option::is_none")]
223    pub external_execution_url: Option<String>,
224    /// <p>The last status change of the action.</p>
225    #[serde(rename = "lastStatusChange")]
226    #[serde(skip_serializing_if = "Option::is_none")]
227    pub last_status_change: Option<f64>,
228    /// <p>The ARN of the user who last changed the pipeline.</p>
229    #[serde(rename = "lastUpdatedBy")]
230    #[serde(skip_serializing_if = "Option::is_none")]
231    pub last_updated_by: Option<String>,
232    /// <p>A percentage of completeness of the action as it runs.</p>
233    #[serde(rename = "percentComplete")]
234    #[serde(skip_serializing_if = "Option::is_none")]
235    pub percent_complete: Option<i64>,
236    /// <p>The status of the action, or for a completed action, the last status of the action.</p>
237    #[serde(rename = "status")]
238    #[serde(skip_serializing_if = "Option::is_none")]
239    pub status: Option<String>,
240    /// <p>A summary of the run of the action.</p>
241    #[serde(rename = "summary")]
242    #[serde(skip_serializing_if = "Option::is_none")]
243    pub summary: Option<String>,
244    /// <p>The system-generated token used to identify a unique approval request. The token for each open approval request can be obtained using the <code>GetPipelineState</code> command. It is used to validate that the approval request corresponding to this token is still valid.</p>
245    #[serde(rename = "token")]
246    #[serde(skip_serializing_if = "Option::is_none")]
247    pub token: Option<String>,
248}
249
250/// <p>Returns information about an execution of an action, including the action execution ID, and the name, version, and timing of the action. </p>
251#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
252#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
253pub struct ActionExecutionDetail {
254    /// <p>The action execution ID.</p>
255    #[serde(rename = "actionExecutionId")]
256    #[serde(skip_serializing_if = "Option::is_none")]
257    pub action_execution_id: Option<String>,
258    /// <p>The name of the action.</p>
259    #[serde(rename = "actionName")]
260    #[serde(skip_serializing_if = "Option::is_none")]
261    pub action_name: Option<String>,
262    /// <p>Input details for the action execution, such as role ARN, Region, and input artifacts.</p>
263    #[serde(rename = "input")]
264    #[serde(skip_serializing_if = "Option::is_none")]
265    pub input: Option<ActionExecutionInput>,
266    /// <p>The last update time of the action execution.</p>
267    #[serde(rename = "lastUpdateTime")]
268    #[serde(skip_serializing_if = "Option::is_none")]
269    pub last_update_time: Option<f64>,
270    /// <p>Output details for the action execution, such as the action execution result.</p>
271    #[serde(rename = "output")]
272    #[serde(skip_serializing_if = "Option::is_none")]
273    pub output: Option<ActionExecutionOutput>,
274    /// <p>The pipeline execution ID for the action execution.</p>
275    #[serde(rename = "pipelineExecutionId")]
276    #[serde(skip_serializing_if = "Option::is_none")]
277    pub pipeline_execution_id: Option<String>,
278    /// <p>The version of the pipeline where the action was run.</p>
279    #[serde(rename = "pipelineVersion")]
280    #[serde(skip_serializing_if = "Option::is_none")]
281    pub pipeline_version: Option<i64>,
282    /// <p>The name of the stage that contains the action.</p>
283    #[serde(rename = "stageName")]
284    #[serde(skip_serializing_if = "Option::is_none")]
285    pub stage_name: Option<String>,
286    /// <p>The start time of the action execution.</p>
287    #[serde(rename = "startTime")]
288    #[serde(skip_serializing_if = "Option::is_none")]
289    pub start_time: Option<f64>,
290    /// <p> The status of the action execution. Status categories are <code>InProgress</code>, <code>Succeeded</code>, and <code>Failed</code>.</p>
291    #[serde(rename = "status")]
292    #[serde(skip_serializing_if = "Option::is_none")]
293    pub status: Option<String>,
294}
295
296/// <p>Filter values for the action execution.</p>
297#[derive(Clone, Debug, Default, PartialEq, Serialize)]
298#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
299pub struct ActionExecutionFilter {
300    /// <p>The pipeline execution ID used to filter action execution history.</p>
301    #[serde(rename = "pipelineExecutionId")]
302    #[serde(skip_serializing_if = "Option::is_none")]
303    pub pipeline_execution_id: Option<String>,
304}
305
306/// <p>Input information used for an action execution.</p>
307#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
308#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
309pub struct ActionExecutionInput {
310    #[serde(rename = "actionTypeId")]
311    #[serde(skip_serializing_if = "Option::is_none")]
312    pub action_type_id: Option<ActionTypeId>,
313    /// <p>Configuration data for an action execution.</p>
314    #[serde(rename = "configuration")]
315    #[serde(skip_serializing_if = "Option::is_none")]
316    pub configuration: Option<::std::collections::HashMap<String, String>>,
317    /// <p>Details of input artifacts of the action that correspond to the action execution.</p>
318    #[serde(rename = "inputArtifacts")]
319    #[serde(skip_serializing_if = "Option::is_none")]
320    pub input_artifacts: Option<Vec<ArtifactDetail>>,
321    /// <p>The variable namespace associated with the action. All variables produced as output by this action fall under this namespace.</p>
322    #[serde(rename = "namespace")]
323    #[serde(skip_serializing_if = "Option::is_none")]
324    pub namespace: Option<String>,
325    /// <p>The AWS Region for the action, such as us-east-1.</p>
326    #[serde(rename = "region")]
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub region: Option<String>,
329    /// <p>Configuration data for an action execution with all variable references replaced with their real values for the execution.</p>
330    #[serde(rename = "resolvedConfiguration")]
331    #[serde(skip_serializing_if = "Option::is_none")]
332    pub resolved_configuration: Option<::std::collections::HashMap<String, String>>,
333    /// <p>The ARN of the IAM service role that performs the declared action. This is assumed through the roleArn for the pipeline. </p>
334    #[serde(rename = "roleArn")]
335    #[serde(skip_serializing_if = "Option::is_none")]
336    pub role_arn: Option<String>,
337}
338
339/// <p>Output details listed for an action execution, such as the action execution result.</p>
340#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
341#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
342pub struct ActionExecutionOutput {
343    /// <p>Execution result information listed in the output details for an action execution.</p>
344    #[serde(rename = "executionResult")]
345    #[serde(skip_serializing_if = "Option::is_none")]
346    pub execution_result: Option<ActionExecutionResult>,
347    /// <p>Details of output artifacts of the action that correspond to the action execution.</p>
348    #[serde(rename = "outputArtifacts")]
349    #[serde(skip_serializing_if = "Option::is_none")]
350    pub output_artifacts: Option<Vec<ArtifactDetail>>,
351    /// <p>The outputVariables field shows the key-value pairs that were output as part of that execution.</p>
352    #[serde(rename = "outputVariables")]
353    #[serde(skip_serializing_if = "Option::is_none")]
354    pub output_variables: Option<::std::collections::HashMap<String, String>>,
355}
356
357/// <p>Execution result information, such as the external execution ID.</p>
358#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
359#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
360pub struct ActionExecutionResult {
361    /// <p>The action provider's external ID for the action execution.</p>
362    #[serde(rename = "externalExecutionId")]
363    #[serde(skip_serializing_if = "Option::is_none")]
364    pub external_execution_id: Option<String>,
365    /// <p>The action provider's summary for the action execution.</p>
366    #[serde(rename = "externalExecutionSummary")]
367    #[serde(skip_serializing_if = "Option::is_none")]
368    pub external_execution_summary: Option<String>,
369    /// <p>The deepest external link to the external resource (for example, a repository URL or deployment endpoint) that is used when running the action.</p>
370    #[serde(rename = "externalExecutionUrl")]
371    #[serde(skip_serializing_if = "Option::is_none")]
372    pub external_execution_url: Option<String>,
373}
374
375/// <p>Represents information about the version (or revision) of an action.</p>
376#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
377pub struct ActionRevision {
378    /// <p>The date and time when the most recent version of the action was created, in timestamp format.</p>
379    #[serde(rename = "created")]
380    pub created: Option<f64>,
381    /// <p>The unique identifier of the change that set the state to this revision (for example, a deployment ID or timestamp).</p>
382    #[serde(rename = "revisionChangeId")]
383    pub revision_change_id: Option<String>,
384    /// <p>The system-generated unique ID that identifies the revision number of the action.</p>
385    #[serde(rename = "revisionId")]
386    pub revision_id: String,
387}
388
389/// <p>Represents information about the state of an action.</p>
390#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
391#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
392pub struct ActionState {
393    /// <p>The name of the action.</p>
394    #[serde(rename = "actionName")]
395    #[serde(skip_serializing_if = "Option::is_none")]
396    pub action_name: Option<String>,
397    /// <p>Represents information about the version (or revision) of an action.</p>
398    #[serde(rename = "currentRevision")]
399    #[serde(skip_serializing_if = "Option::is_none")]
400    pub current_revision: Option<ActionRevision>,
401    /// <p>A URL link for more information about the state of the action, such as a deployment group details page.</p>
402    #[serde(rename = "entityUrl")]
403    #[serde(skip_serializing_if = "Option::is_none")]
404    pub entity_url: Option<String>,
405    /// <p>Represents information about the run of an action.</p>
406    #[serde(rename = "latestExecution")]
407    #[serde(skip_serializing_if = "Option::is_none")]
408    pub latest_execution: Option<ActionExecution>,
409    /// <p>A URL link for more information about the revision, such as a commit details page.</p>
410    #[serde(rename = "revisionUrl")]
411    #[serde(skip_serializing_if = "Option::is_none")]
412    pub revision_url: Option<String>,
413}
414
415/// <p>Returns information about the details of an action type.</p>
416#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
417#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
418pub struct ActionType {
419    /// <p>The configuration properties for the action type.</p>
420    #[serde(rename = "actionConfigurationProperties")]
421    #[serde(skip_serializing_if = "Option::is_none")]
422    pub action_configuration_properties: Option<Vec<ActionConfigurationProperty>>,
423    /// <p>Represents information about an action type.</p>
424    #[serde(rename = "id")]
425    pub id: ActionTypeId,
426    /// <p>The details of the input artifact for the action, such as its commit ID.</p>
427    #[serde(rename = "inputArtifactDetails")]
428    pub input_artifact_details: ArtifactDetails,
429    /// <p>The details of the output artifact of the action, such as its commit ID.</p>
430    #[serde(rename = "outputArtifactDetails")]
431    pub output_artifact_details: ArtifactDetails,
432    /// <p>The settings for the action type.</p>
433    #[serde(rename = "settings")]
434    #[serde(skip_serializing_if = "Option::is_none")]
435    pub settings: Option<ActionTypeSettings>,
436}
437
438/// <p>Represents information about an action type.</p>
439#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
440pub struct ActionTypeId {
441    /// <p>A category defines what kind of action can be taken in the stage, and constrains the provider type for the action. Valid categories are limited to one of the following values. </p>
442    #[serde(rename = "category")]
443    pub category: String,
444    /// <p>The creator of the action being called.</p>
445    #[serde(rename = "owner")]
446    pub owner: String,
447    /// <p>The provider of the service being called by the action. Valid providers are determined by the action category. For example, an action in the Deploy category type might have a provider of AWS CodeDeploy, which would be specified as CodeDeploy. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#actions-valid-providers">Valid Action Types and Providers in CodePipeline</a>.</p>
448    #[serde(rename = "provider")]
449    pub provider: String,
450    /// <p>A string that describes the action version.</p>
451    #[serde(rename = "version")]
452    pub version: String,
453}
454
455/// <p>Returns information about the settings for an action type.</p>
456#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
457pub struct ActionTypeSettings {
458    /// <p>The URL returned to the AWS CodePipeline console that provides a deep link to the resources of the external system, such as the configuration page for an AWS CodeDeploy deployment group. This link is provided as part of the action display in the pipeline.</p>
459    #[serde(rename = "entityUrlTemplate")]
460    #[serde(skip_serializing_if = "Option::is_none")]
461    pub entity_url_template: Option<String>,
462    /// <p>The URL returned to the AWS CodePipeline console that contains a link to the top-level landing page for the external system, such as the console page for AWS CodeDeploy. This link is shown on the pipeline view page in the AWS CodePipeline console and provides a link to the execution entity of the external action.</p>
463    #[serde(rename = "executionUrlTemplate")]
464    #[serde(skip_serializing_if = "Option::is_none")]
465    pub execution_url_template: Option<String>,
466    /// <p>The URL returned to the AWS CodePipeline console that contains a link to the page where customers can update or change the configuration of the external action.</p>
467    #[serde(rename = "revisionUrlTemplate")]
468    #[serde(skip_serializing_if = "Option::is_none")]
469    pub revision_url_template: Option<String>,
470    /// <p>The URL of a sign-up page where users can sign up for an external service and perform initial configuration of the action provided by that service.</p>
471    #[serde(rename = "thirdPartyConfigurationUrl")]
472    #[serde(skip_serializing_if = "Option::is_none")]
473    pub third_party_configuration_url: Option<String>,
474}
475
476/// <p>Represents information about the result of an approval request.</p>
477#[derive(Clone, Debug, Default, PartialEq, Serialize)]
478#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
479pub struct ApprovalResult {
480    /// <p>The response submitted by a reviewer assigned to an approval action request.</p>
481    #[serde(rename = "status")]
482    pub status: String,
483    /// <p>The summary of the current status of the approval request.</p>
484    #[serde(rename = "summary")]
485    pub summary: String,
486}
487
488/// <p>Represents information about an artifact that is worked on by actions in the pipeline.</p>
489#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
490#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
491pub struct Artifact {
492    /// <p>The location of an artifact.</p>
493    #[serde(rename = "location")]
494    #[serde(skip_serializing_if = "Option::is_none")]
495    pub location: Option<ArtifactLocation>,
496    /// <p>The artifact's name.</p>
497    #[serde(rename = "name")]
498    #[serde(skip_serializing_if = "Option::is_none")]
499    pub name: Option<String>,
500    /// <p>The artifact's revision ID. Depending on the type of object, this could be a commit ID (GitHub) or a revision ID (Amazon S3).</p>
501    #[serde(rename = "revision")]
502    #[serde(skip_serializing_if = "Option::is_none")]
503    pub revision: Option<String>,
504}
505
506/// <p>Artifact details for the action execution, such as the artifact location.</p>
507#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
508#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
509pub struct ArtifactDetail {
510    /// <p>The artifact object name for the action execution.</p>
511    #[serde(rename = "name")]
512    #[serde(skip_serializing_if = "Option::is_none")]
513    pub name: Option<String>,
514    /// <p>The Amazon S3 artifact location for the action execution.</p>
515    #[serde(rename = "s3location")]
516    #[serde(skip_serializing_if = "Option::is_none")]
517    pub s_3location: Option<S3Location>,
518}
519
520/// <p>Returns information about the details of an artifact.</p>
521#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
522pub struct ArtifactDetails {
523    /// <p>The maximum number of artifacts allowed for the action type.</p>
524    #[serde(rename = "maximumCount")]
525    pub maximum_count: i64,
526    /// <p>The minimum number of artifacts allowed for the action type.</p>
527    #[serde(rename = "minimumCount")]
528    pub minimum_count: i64,
529}
530
531/// <p>Represents information about the location of an artifact.</p>
532#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
533#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
534pub struct ArtifactLocation {
535    /// <p>The S3 bucket that contains the artifact.</p>
536    #[serde(rename = "s3Location")]
537    #[serde(skip_serializing_if = "Option::is_none")]
538    pub s_3_location: Option<S3ArtifactLocation>,
539    /// <p>The type of artifact in the location.</p>
540    #[serde(rename = "type")]
541    #[serde(skip_serializing_if = "Option::is_none")]
542    pub type_: Option<String>,
543}
544
545/// <p>Represents revision details of an artifact. </p>
546#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
547#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
548pub struct ArtifactRevision {
549    /// <p>The date and time when the most recent revision of the artifact was created, in timestamp format.</p>
550    #[serde(rename = "created")]
551    #[serde(skip_serializing_if = "Option::is_none")]
552    pub created: Option<f64>,
553    /// <p>The name of an artifact. This name might be system-generated, such as "MyApp", or defined by the user when an action is created.</p>
554    #[serde(rename = "name")]
555    #[serde(skip_serializing_if = "Option::is_none")]
556    pub name: Option<String>,
557    /// <p>An additional identifier for a revision, such as a commit date or, for artifacts stored in Amazon S3 buckets, the ETag value.</p>
558    #[serde(rename = "revisionChangeIdentifier")]
559    #[serde(skip_serializing_if = "Option::is_none")]
560    pub revision_change_identifier: Option<String>,
561    /// <p>The revision ID of the artifact.</p>
562    #[serde(rename = "revisionId")]
563    #[serde(skip_serializing_if = "Option::is_none")]
564    pub revision_id: Option<String>,
565    /// <p>Summary information about the most recent revision of the artifact. For GitHub and AWS CodeCommit repositories, the commit message. For Amazon S3 buckets or actions, the user-provided content of a <code>codepipeline-artifact-revision-summary</code> key specified in the object metadata.</p>
566    #[serde(rename = "revisionSummary")]
567    #[serde(skip_serializing_if = "Option::is_none")]
568    pub revision_summary: Option<String>,
569    /// <p>The commit ID for the artifact revision. For artifacts stored in GitHub or AWS CodeCommit repositories, the commit ID is linked to a commit details page.</p>
570    #[serde(rename = "revisionUrl")]
571    #[serde(skip_serializing_if = "Option::is_none")]
572    pub revision_url: Option<String>,
573}
574
575/// <p><p>The S3 bucket where artifacts for the pipeline are stored.</p> <note> <p>You must include either <code>artifactStore</code> or <code>artifactStores</code> in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use <code>artifactStores</code>.</p> </note></p>
576#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
577pub struct ArtifactStore {
578    /// <p>The encryption key used to encrypt the data in the artifact store, such as an AWS Key Management Service (AWS KMS) key. If this is undefined, the default key for Amazon S3 is used.</p>
579    #[serde(rename = "encryptionKey")]
580    #[serde(skip_serializing_if = "Option::is_none")]
581    pub encryption_key: Option<EncryptionKey>,
582    /// <p>The S3 bucket used for storing the artifacts for a pipeline. You can specify the name of an S3 bucket but not a folder in the bucket. A folder to contain the pipeline artifacts is created for you based on the name of the pipeline. You can use any S3 bucket in the same AWS Region as the pipeline to store your pipeline artifacts.</p>
583    #[serde(rename = "location")]
584    pub location: String,
585    /// <p>The type of the artifact store, such as S3.</p>
586    #[serde(rename = "type")]
587    pub type_: String,
588}
589
590/// <p>Reserved for future use.</p>
591#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
592pub struct BlockerDeclaration {
593    /// <p>Reserved for future use.</p>
594    #[serde(rename = "name")]
595    pub name: String,
596    /// <p>Reserved for future use.</p>
597    #[serde(rename = "type")]
598    pub type_: String,
599}
600
601/// <p>Represents the input of a CreateCustomActionType operation.</p>
602#[derive(Clone, Debug, Default, PartialEq, Serialize)]
603#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
604pub struct CreateCustomActionTypeInput {
605    /// <p><p>The category of the custom action, such as a build action or a test action.</p> <note> <p>Although <code>Source</code> and <code>Approval</code> are listed as valid values, they are not currently functional. These values are reserved for future use.</p> </note></p>
606    #[serde(rename = "category")]
607    pub category: String,
608    /// <p><p>The configuration properties for the custom action.</p> <note> <p>You can refer to a name in the configuration properties of the custom action within the URL templates by following the format of {Config:name}, as long as the configuration property is both required and not secret. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/how-to-create-custom-action.html">Create a Custom Action for a Pipeline</a>.</p> </note></p>
609    #[serde(rename = "configurationProperties")]
610    #[serde(skip_serializing_if = "Option::is_none")]
611    pub configuration_properties: Option<Vec<ActionConfigurationProperty>>,
612    /// <p>The details of the input artifact for the action, such as its commit ID.</p>
613    #[serde(rename = "inputArtifactDetails")]
614    pub input_artifact_details: ArtifactDetails,
615    /// <p>The details of the output artifact of the action, such as its commit ID.</p>
616    #[serde(rename = "outputArtifactDetails")]
617    pub output_artifact_details: ArtifactDetails,
618    /// <p>The provider of the service used in the custom action, such as AWS CodeDeploy.</p>
619    #[serde(rename = "provider")]
620    pub provider: String,
621    /// <p>URLs that provide users information about this custom action.</p>
622    #[serde(rename = "settings")]
623    #[serde(skip_serializing_if = "Option::is_none")]
624    pub settings: Option<ActionTypeSettings>,
625    /// <p>The tags for the custom action.</p>
626    #[serde(rename = "tags")]
627    #[serde(skip_serializing_if = "Option::is_none")]
628    pub tags: Option<Vec<Tag>>,
629    /// <p>The version identifier of the custom action.</p>
630    #[serde(rename = "version")]
631    pub version: String,
632}
633
634/// <p>Represents the output of a <code>CreateCustomActionType</code> operation.</p>
635#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
636#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
637pub struct CreateCustomActionTypeOutput {
638    /// <p>Returns information about the details of an action type.</p>
639    #[serde(rename = "actionType")]
640    pub action_type: ActionType,
641    /// <p>Specifies the tags applied to the custom action.</p>
642    #[serde(rename = "tags")]
643    #[serde(skip_serializing_if = "Option::is_none")]
644    pub tags: Option<Vec<Tag>>,
645}
646
647/// <p>Represents the input of a <code>CreatePipeline</code> action.</p>
648#[derive(Clone, Debug, Default, PartialEq, Serialize)]
649#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
650pub struct CreatePipelineInput {
651    /// <p>Represents the structure of actions and stages to be performed in the pipeline. </p>
652    #[serde(rename = "pipeline")]
653    pub pipeline: PipelineDeclaration,
654    /// <p>The tags for the pipeline.</p>
655    #[serde(rename = "tags")]
656    #[serde(skip_serializing_if = "Option::is_none")]
657    pub tags: Option<Vec<Tag>>,
658}
659
660/// <p>Represents the output of a <code>CreatePipeline</code> action.</p>
661#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
662#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
663pub struct CreatePipelineOutput {
664    /// <p>Represents the structure of actions and stages to be performed in the pipeline. </p>
665    #[serde(rename = "pipeline")]
666    #[serde(skip_serializing_if = "Option::is_none")]
667    pub pipeline: Option<PipelineDeclaration>,
668    /// <p>Specifies the tags applied to the pipeline.</p>
669    #[serde(rename = "tags")]
670    #[serde(skip_serializing_if = "Option::is_none")]
671    pub tags: Option<Vec<Tag>>,
672}
673
674/// <p>Represents information about a current revision.</p>
675#[derive(Clone, Debug, Default, PartialEq, Serialize)]
676#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
677pub struct CurrentRevision {
678    /// <p>The change identifier for the current revision.</p>
679    #[serde(rename = "changeIdentifier")]
680    pub change_identifier: String,
681    /// <p>The date and time when the most recent revision of the artifact was created, in timestamp format.</p>
682    #[serde(rename = "created")]
683    #[serde(skip_serializing_if = "Option::is_none")]
684    pub created: Option<f64>,
685    /// <p>The revision ID of the current version of an artifact.</p>
686    #[serde(rename = "revision")]
687    pub revision: String,
688    /// <p>The summary of the most recent revision of the artifact.</p>
689    #[serde(rename = "revisionSummary")]
690    #[serde(skip_serializing_if = "Option::is_none")]
691    pub revision_summary: Option<String>,
692}
693
694/// <p>Represents the input of a <code>DeleteCustomActionType</code> operation. The custom action will be marked as deleted.</p>
695#[derive(Clone, Debug, Default, PartialEq, Serialize)]
696#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
697pub struct DeleteCustomActionTypeInput {
698    /// <p>The category of the custom action that you want to delete, such as source or deploy.</p>
699    #[serde(rename = "category")]
700    pub category: String,
701    /// <p>The provider of the service used in the custom action, such as AWS CodeDeploy.</p>
702    #[serde(rename = "provider")]
703    pub provider: String,
704    /// <p>The version of the custom action to delete.</p>
705    #[serde(rename = "version")]
706    pub version: String,
707}
708
709/// <p>Represents the input of a <code>DeletePipeline</code> action.</p>
710#[derive(Clone, Debug, Default, PartialEq, Serialize)]
711#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
712pub struct DeletePipelineInput {
713    /// <p>The name of the pipeline to be deleted.</p>
714    #[serde(rename = "name")]
715    pub name: String,
716}
717
718#[derive(Clone, Debug, Default, PartialEq, Serialize)]
719#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
720pub struct DeleteWebhookInput {
721    /// <p>The name of the webhook you want to delete.</p>
722    #[serde(rename = "name")]
723    pub name: String,
724}
725
726#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
727#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
728pub struct DeleteWebhookOutput {}
729
730#[derive(Clone, Debug, Default, PartialEq, Serialize)]
731#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
732pub struct DeregisterWebhookWithThirdPartyInput {
733    /// <p>The name of the webhook you want to deregister.</p>
734    #[serde(rename = "webhookName")]
735    #[serde(skip_serializing_if = "Option::is_none")]
736    pub webhook_name: Option<String>,
737}
738
739#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
740#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
741pub struct DeregisterWebhookWithThirdPartyOutput {}
742
743/// <p>Represents the input of a <code>DisableStageTransition</code> action.</p>
744#[derive(Clone, Debug, Default, PartialEq, Serialize)]
745#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
746pub struct DisableStageTransitionInput {
747    /// <p>The name of the pipeline in which you want to disable the flow of artifacts from one stage to another.</p>
748    #[serde(rename = "pipelineName")]
749    pub pipeline_name: String,
750    /// <p>The reason given to the user that a stage is disabled, such as waiting for manual approval or manual tests. This message is displayed in the pipeline console UI.</p>
751    #[serde(rename = "reason")]
752    pub reason: String,
753    /// <p>The name of the stage where you want to disable the inbound or outbound transition of artifacts.</p>
754    #[serde(rename = "stageName")]
755    pub stage_name: String,
756    /// <p>Specifies whether artifacts are prevented from transitioning into the stage and being processed by the actions in that stage (inbound), or prevented from transitioning from the stage after they have been processed by the actions in that stage (outbound).</p>
757    #[serde(rename = "transitionType")]
758    pub transition_type: String,
759}
760
761/// <p>Represents the input of an <code>EnableStageTransition</code> action.</p>
762#[derive(Clone, Debug, Default, PartialEq, Serialize)]
763#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
764pub struct EnableStageTransitionInput {
765    /// <p>The name of the pipeline in which you want to enable the flow of artifacts from one stage to another.</p>
766    #[serde(rename = "pipelineName")]
767    pub pipeline_name: String,
768    /// <p>The name of the stage where you want to enable the transition of artifacts, either into the stage (inbound) or from that stage to the next stage (outbound).</p>
769    #[serde(rename = "stageName")]
770    pub stage_name: String,
771    /// <p>Specifies whether artifacts are allowed to enter the stage and be processed by the actions in that stage (inbound) or whether already processed artifacts are allowed to transition to the next stage (outbound).</p>
772    #[serde(rename = "transitionType")]
773    pub transition_type: String,
774}
775
776/// <p>Represents information about the key used to encrypt data in the artifact store, such as an AWS Key Management Service (AWS KMS) key.</p>
777#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
778pub struct EncryptionKey {
779    /// <p><p>The ID used to identify the key. For an AWS KMS key, you can use the key ID, the key ARN, or the alias ARN.</p> <note> <p>Aliases are recognized only in the account that created the customer master key (CMK). For cross-account actions, you can only use the key ID or key ARN to identify the key.</p> </note></p>
780    #[serde(rename = "id")]
781    pub id: String,
782    /// <p>The type of encryption key, such as an AWS Key Management Service (AWS KMS) key. When creating or updating a pipeline, the value must be set to 'KMS'.</p>
783    #[serde(rename = "type")]
784    pub type_: String,
785}
786
787/// <p>Represents information about an error in AWS CodePipeline.</p>
788#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
789#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
790pub struct ErrorDetails {
791    /// <p>The system ID or number code of the error.</p>
792    #[serde(rename = "code")]
793    #[serde(skip_serializing_if = "Option::is_none")]
794    pub code: Option<String>,
795    /// <p>The text of the error message.</p>
796    #[serde(rename = "message")]
797    #[serde(skip_serializing_if = "Option::is_none")]
798    pub message: Option<String>,
799}
800
801/// <p>The details of the actions taken and results produced on an artifact as it passes through stages in the pipeline.</p>
802#[derive(Clone, Debug, Default, PartialEq, Serialize)]
803#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
804pub struct ExecutionDetails {
805    /// <p>The system-generated unique ID of this action used to identify this job worker in any external systems, such as AWS CodeDeploy.</p>
806    #[serde(rename = "externalExecutionId")]
807    #[serde(skip_serializing_if = "Option::is_none")]
808    pub external_execution_id: Option<String>,
809    /// <p>The percentage of work completed on the action, represented on a scale of 0 to 100 percent.</p>
810    #[serde(rename = "percentComplete")]
811    #[serde(skip_serializing_if = "Option::is_none")]
812    pub percent_complete: Option<i64>,
813    /// <p>The summary of the current status of the actions.</p>
814    #[serde(rename = "summary")]
815    #[serde(skip_serializing_if = "Option::is_none")]
816    pub summary: Option<String>,
817}
818
819/// <p>The interaction or event that started a pipeline execution.</p>
820#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
821#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
822pub struct ExecutionTrigger {
823    /// <p>Detail related to the event that started a pipeline execution, such as the webhook ARN of the webhook that triggered the pipeline execution or the user ARN for a user-initiated <code>start-pipeline-execution</code> CLI command.</p>
824    #[serde(rename = "triggerDetail")]
825    #[serde(skip_serializing_if = "Option::is_none")]
826    pub trigger_detail: Option<String>,
827    /// <p>The type of change-detection method, command, or user interaction that started a pipeline execution.</p>
828    #[serde(rename = "triggerType")]
829    #[serde(skip_serializing_if = "Option::is_none")]
830    pub trigger_type: Option<String>,
831}
832
833/// <p>Represents information about failure details.</p>
834#[derive(Clone, Debug, Default, PartialEq, Serialize)]
835#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
836pub struct FailureDetails {
837    /// <p>The external ID of the run of the action that failed.</p>
838    #[serde(rename = "externalExecutionId")]
839    #[serde(skip_serializing_if = "Option::is_none")]
840    pub external_execution_id: Option<String>,
841    /// <p>The message about the failure.</p>
842    #[serde(rename = "message")]
843    pub message: String,
844    /// <p>The type of the failure.</p>
845    #[serde(rename = "type")]
846    pub type_: String,
847}
848
849/// <p>Represents the input of a <code>GetJobDetails</code> action.</p>
850#[derive(Clone, Debug, Default, PartialEq, Serialize)]
851#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
852pub struct GetJobDetailsInput {
853    /// <p>The unique system-generated ID for the job.</p>
854    #[serde(rename = "jobId")]
855    pub job_id: String,
856}
857
858/// <p>Represents the output of a <code>GetJobDetails</code> action.</p>
859#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
860#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
861pub struct GetJobDetailsOutput {
862    /// <p><p>The details of the job.</p> <note> <p>If AWSSessionCredentials is used, a long-running job can call <code>GetJobDetails</code> again to obtain new credentials.</p> </note></p>
863    #[serde(rename = "jobDetails")]
864    #[serde(skip_serializing_if = "Option::is_none")]
865    pub job_details: Option<JobDetails>,
866}
867
868/// <p>Represents the input of a <code>GetPipelineExecution</code> action.</p>
869#[derive(Clone, Debug, Default, PartialEq, Serialize)]
870#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
871pub struct GetPipelineExecutionInput {
872    /// <p>The ID of the pipeline execution about which you want to get execution details.</p>
873    #[serde(rename = "pipelineExecutionId")]
874    pub pipeline_execution_id: String,
875    /// <p>The name of the pipeline about which you want to get execution details.</p>
876    #[serde(rename = "pipelineName")]
877    pub pipeline_name: String,
878}
879
880/// <p>Represents the output of a <code>GetPipelineExecution</code> action.</p>
881#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
882#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
883pub struct GetPipelineExecutionOutput {
884    /// <p>Represents information about the execution of a pipeline.</p>
885    #[serde(rename = "pipelineExecution")]
886    #[serde(skip_serializing_if = "Option::is_none")]
887    pub pipeline_execution: Option<PipelineExecution>,
888}
889
890/// <p>Represents the input of a <code>GetPipeline</code> action.</p>
891#[derive(Clone, Debug, Default, PartialEq, Serialize)]
892#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
893pub struct GetPipelineInput {
894    /// <p>The name of the pipeline for which you want to get information. Pipeline names must be unique under an AWS user account.</p>
895    #[serde(rename = "name")]
896    pub name: String,
897    /// <p>The version number of the pipeline. If you do not specify a version, defaults to the current version.</p>
898    #[serde(rename = "version")]
899    #[serde(skip_serializing_if = "Option::is_none")]
900    pub version: Option<i64>,
901}
902
903/// <p>Represents the output of a <code>GetPipeline</code> action.</p>
904#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
905#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
906pub struct GetPipelineOutput {
907    /// <p>Represents the pipeline metadata information returned as part of the output of a <code>GetPipeline</code> action.</p>
908    #[serde(rename = "metadata")]
909    #[serde(skip_serializing_if = "Option::is_none")]
910    pub metadata: Option<PipelineMetadata>,
911    /// <p>Represents the structure of actions and stages to be performed in the pipeline. </p>
912    #[serde(rename = "pipeline")]
913    #[serde(skip_serializing_if = "Option::is_none")]
914    pub pipeline: Option<PipelineDeclaration>,
915}
916
917/// <p>Represents the input of a <code>GetPipelineState</code> action.</p>
918#[derive(Clone, Debug, Default, PartialEq, Serialize)]
919#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
920pub struct GetPipelineStateInput {
921    /// <p>The name of the pipeline about which you want to get information.</p>
922    #[serde(rename = "name")]
923    pub name: String,
924}
925
926/// <p>Represents the output of a <code>GetPipelineState</code> action.</p>
927#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
928#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
929pub struct GetPipelineStateOutput {
930    /// <p>The date and time the pipeline was created, in timestamp format.</p>
931    #[serde(rename = "created")]
932    #[serde(skip_serializing_if = "Option::is_none")]
933    pub created: Option<f64>,
934    /// <p>The name of the pipeline for which you want to get the state.</p>
935    #[serde(rename = "pipelineName")]
936    #[serde(skip_serializing_if = "Option::is_none")]
937    pub pipeline_name: Option<String>,
938    /// <p><p>The version number of the pipeline.</p> <note> <p>A newly created pipeline is always assigned a version number of <code>1</code>.</p> </note></p>
939    #[serde(rename = "pipelineVersion")]
940    #[serde(skip_serializing_if = "Option::is_none")]
941    pub pipeline_version: Option<i64>,
942    /// <p>A list of the pipeline stage output information, including stage name, state, most recent run details, whether the stage is disabled, and other data.</p>
943    #[serde(rename = "stageStates")]
944    #[serde(skip_serializing_if = "Option::is_none")]
945    pub stage_states: Option<Vec<StageState>>,
946    /// <p>The date and time the pipeline was last updated, in timestamp format.</p>
947    #[serde(rename = "updated")]
948    #[serde(skip_serializing_if = "Option::is_none")]
949    pub updated: Option<f64>,
950}
951
952/// <p>Represents the input of a <code>GetThirdPartyJobDetails</code> action.</p>
953#[derive(Clone, Debug, Default, PartialEq, Serialize)]
954#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
955pub struct GetThirdPartyJobDetailsInput {
956    /// <p>The clientToken portion of the clientId and clientToken pair used to verify that the calling entity is allowed access to the job and its details.</p>
957    #[serde(rename = "clientToken")]
958    pub client_token: String,
959    /// <p>The unique system-generated ID used for identifying the job.</p>
960    #[serde(rename = "jobId")]
961    pub job_id: String,
962}
963
964/// <p>Represents the output of a <code>GetThirdPartyJobDetails</code> action.</p>
965#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
966#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
967pub struct GetThirdPartyJobDetailsOutput {
968    /// <p>The details of the job, including any protected values defined for the job.</p>
969    #[serde(rename = "jobDetails")]
970    #[serde(skip_serializing_if = "Option::is_none")]
971    pub job_details: Option<ThirdPartyJobDetails>,
972}
973
974/// <p>Represents information about an artifact to be worked on, such as a test or build artifact.</p>
975#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
976pub struct InputArtifact {
977    /// <p>The name of the artifact to be worked on (for example, "My App").</p> <p>The input artifact of an action must exactly match the output artifact declared in a preceding action, but the input artifact does not have to be the next action in strict sequence from the action that provided the output artifact. Actions in parallel can declare different output artifacts, which are in turn consumed by different following actions.</p>
978    #[serde(rename = "name")]
979    pub name: String,
980}
981
982/// <p>Represents information about a job.</p>
983#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
984#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
985pub struct Job {
986    /// <p>The ID of the AWS account to use when performing the job.</p>
987    #[serde(rename = "accountId")]
988    #[serde(skip_serializing_if = "Option::is_none")]
989    pub account_id: Option<String>,
990    /// <p>Other data about a job.</p>
991    #[serde(rename = "data")]
992    #[serde(skip_serializing_if = "Option::is_none")]
993    pub data: Option<JobData>,
994    /// <p>The unique system-generated ID of the job.</p>
995    #[serde(rename = "id")]
996    #[serde(skip_serializing_if = "Option::is_none")]
997    pub id: Option<String>,
998    /// <p>A system-generated random number that AWS CodePipeline uses to ensure that the job is being worked on by only one job worker. Use this number in an <a>AcknowledgeJob</a> request.</p>
999    #[serde(rename = "nonce")]
1000    #[serde(skip_serializing_if = "Option::is_none")]
1001    pub nonce: Option<String>,
1002}
1003
1004/// <p>Represents other information about a job required for a job worker to complete the job.</p>
1005#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1006#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1007pub struct JobData {
1008    /// <p>Represents information about an action configuration.</p>
1009    #[serde(rename = "actionConfiguration")]
1010    #[serde(skip_serializing_if = "Option::is_none")]
1011    pub action_configuration: Option<ActionConfiguration>,
1012    /// <p>Represents information about an action type.</p>
1013    #[serde(rename = "actionTypeId")]
1014    #[serde(skip_serializing_if = "Option::is_none")]
1015    pub action_type_id: Option<ActionTypeId>,
1016    /// <p>Represents an AWS session credentials object. These credentials are temporary credentials that are issued by AWS Secure Token Service (STS). They can be used to access input and output artifacts in the S3 bucket used to store artifacts for the pipeline in AWS CodePipeline.</p>
1017    #[serde(rename = "artifactCredentials")]
1018    #[serde(skip_serializing_if = "Option::is_none")]
1019    pub artifact_credentials: Option<AWSSessionCredentials>,
1020    /// <p>A system-generated token, such as a AWS CodeDeploy deployment ID, required by a job to continue the job asynchronously.</p>
1021    #[serde(rename = "continuationToken")]
1022    #[serde(skip_serializing_if = "Option::is_none")]
1023    pub continuation_token: Option<String>,
1024    /// <p>Represents information about the key used to encrypt data in the artifact store, such as an AWS Key Management Service (AWS KMS) key. </p>
1025    #[serde(rename = "encryptionKey")]
1026    #[serde(skip_serializing_if = "Option::is_none")]
1027    pub encryption_key: Option<EncryptionKey>,
1028    /// <p>The artifact supplied to the job.</p>
1029    #[serde(rename = "inputArtifacts")]
1030    #[serde(skip_serializing_if = "Option::is_none")]
1031    pub input_artifacts: Option<Vec<Artifact>>,
1032    /// <p>The output of the job.</p>
1033    #[serde(rename = "outputArtifacts")]
1034    #[serde(skip_serializing_if = "Option::is_none")]
1035    pub output_artifacts: Option<Vec<Artifact>>,
1036    /// <p><p>Represents information about a pipeline to a job worker.</p> <note> <p>Includes <code>pipelineArn</code> and <code>pipelineExecutionId</code> for custom jobs.</p> </note></p>
1037    #[serde(rename = "pipelineContext")]
1038    #[serde(skip_serializing_if = "Option::is_none")]
1039    pub pipeline_context: Option<PipelineContext>,
1040}
1041
1042/// <p>Represents information about the details of a job.</p>
1043#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1044#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1045pub struct JobDetails {
1046    /// <p>The AWS account ID associated with the job.</p>
1047    #[serde(rename = "accountId")]
1048    #[serde(skip_serializing_if = "Option::is_none")]
1049    pub account_id: Option<String>,
1050    /// <p>Represents other information about a job required for a job worker to complete the job. </p>
1051    #[serde(rename = "data")]
1052    #[serde(skip_serializing_if = "Option::is_none")]
1053    pub data: Option<JobData>,
1054    /// <p>The unique system-generated ID of the job.</p>
1055    #[serde(rename = "id")]
1056    #[serde(skip_serializing_if = "Option::is_none")]
1057    pub id: Option<String>,
1058}
1059
1060#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1061#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1062pub struct ListActionExecutionsInput {
1063    /// <p>Input information used to filter action execution history.</p>
1064    #[serde(rename = "filter")]
1065    #[serde(skip_serializing_if = "Option::is_none")]
1066    pub filter: Option<ActionExecutionFilter>,
1067    /// <p><p>The maximum number of results to return in a single call. To retrieve the remaining results, make another call with the returned nextToken value. Action execution history is retained for up to 12 months, based on action execution start times. Default value is 100. </p> <note> <p>Detailed execution history is available for executions run on or after February 21, 2019.</p> </note></p>
1068    #[serde(rename = "maxResults")]
1069    #[serde(skip_serializing_if = "Option::is_none")]
1070    pub max_results: Option<i64>,
1071    /// <p>The token that was returned from the previous <code>ListActionExecutions</code> call, which can be used to return the next set of action executions in the list.</p>
1072    #[serde(rename = "nextToken")]
1073    #[serde(skip_serializing_if = "Option::is_none")]
1074    pub next_token: Option<String>,
1075    /// <p> The name of the pipeline for which you want to list action execution history.</p>
1076    #[serde(rename = "pipelineName")]
1077    pub pipeline_name: String,
1078}
1079
1080#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1081#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1082pub struct ListActionExecutionsOutput {
1083    /// <p>The details for a list of recent executions, such as action execution ID.</p>
1084    #[serde(rename = "actionExecutionDetails")]
1085    #[serde(skip_serializing_if = "Option::is_none")]
1086    pub action_execution_details: Option<Vec<ActionExecutionDetail>>,
1087    /// <p>If the amount of returned information is significantly large, an identifier is also returned and can be used in a subsequent <code>ListActionExecutions</code> call to return the next set of action executions in the list.</p>
1088    #[serde(rename = "nextToken")]
1089    #[serde(skip_serializing_if = "Option::is_none")]
1090    pub next_token: Option<String>,
1091}
1092
1093/// <p>Represents the input of a <code>ListActionTypes</code> action.</p>
1094#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1095#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1096pub struct ListActionTypesInput {
1097    /// <p>Filters the list of action types to those created by a specified entity.</p>
1098    #[serde(rename = "actionOwnerFilter")]
1099    #[serde(skip_serializing_if = "Option::is_none")]
1100    pub action_owner_filter: Option<String>,
1101    /// <p>An identifier that was returned from the previous list action types call, which can be used to return the next set of action types in the list.</p>
1102    #[serde(rename = "nextToken")]
1103    #[serde(skip_serializing_if = "Option::is_none")]
1104    pub next_token: Option<String>,
1105}
1106
1107/// <p>Represents the output of a <code>ListActionTypes</code> action.</p>
1108#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1109#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1110pub struct ListActionTypesOutput {
1111    /// <p>Provides details of the action types.</p>
1112    #[serde(rename = "actionTypes")]
1113    pub action_types: Vec<ActionType>,
1114    /// <p>If the amount of returned information is significantly large, an identifier is also returned. It can be used in a subsequent list action types call to return the next set of action types in the list.</p>
1115    #[serde(rename = "nextToken")]
1116    #[serde(skip_serializing_if = "Option::is_none")]
1117    pub next_token: Option<String>,
1118}
1119
1120/// <p>Represents the input of a <code>ListPipelineExecutions</code> action.</p>
1121#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1122#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1123pub struct ListPipelineExecutionsInput {
1124    /// <p>The maximum number of results to return in a single call. To retrieve the remaining results, make another call with the returned nextToken value. Pipeline history is limited to the most recent 12 months, based on pipeline execution start times. Default value is 100.</p>
1125    #[serde(rename = "maxResults")]
1126    #[serde(skip_serializing_if = "Option::is_none")]
1127    pub max_results: Option<i64>,
1128    /// <p>The token that was returned from the previous <code>ListPipelineExecutions</code> call, which can be used to return the next set of pipeline executions in the list.</p>
1129    #[serde(rename = "nextToken")]
1130    #[serde(skip_serializing_if = "Option::is_none")]
1131    pub next_token: Option<String>,
1132    /// <p>The name of the pipeline for which you want to get execution summary information.</p>
1133    #[serde(rename = "pipelineName")]
1134    pub pipeline_name: String,
1135}
1136
1137/// <p>Represents the output of a <code>ListPipelineExecutions</code> action.</p>
1138#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1139#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1140pub struct ListPipelineExecutionsOutput {
1141    /// <p>A token that can be used in the next <code>ListPipelineExecutions</code> call. To view all items in the list, continue to call this operation with each subsequent token until no more nextToken values are returned.</p>
1142    #[serde(rename = "nextToken")]
1143    #[serde(skip_serializing_if = "Option::is_none")]
1144    pub next_token: Option<String>,
1145    /// <p>A list of executions in the history of a pipeline.</p>
1146    #[serde(rename = "pipelineExecutionSummaries")]
1147    #[serde(skip_serializing_if = "Option::is_none")]
1148    pub pipeline_execution_summaries: Option<Vec<PipelineExecutionSummary>>,
1149}
1150
1151/// <p>Represents the input of a <code>ListPipelines</code> action.</p>
1152#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1153#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1154pub struct ListPipelinesInput {
1155    /// <p>An identifier that was returned from the previous list pipelines call. It can be used to return the next set of pipelines in the list.</p>
1156    #[serde(rename = "nextToken")]
1157    #[serde(skip_serializing_if = "Option::is_none")]
1158    pub next_token: Option<String>,
1159}
1160
1161/// <p>Represents the output of a <code>ListPipelines</code> action.</p>
1162#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1163#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1164pub struct ListPipelinesOutput {
1165    /// <p>If the amount of returned information is significantly large, an identifier is also returned. It can be used in a subsequent list pipelines call to return the next set of pipelines in the list.</p>
1166    #[serde(rename = "nextToken")]
1167    #[serde(skip_serializing_if = "Option::is_none")]
1168    pub next_token: Option<String>,
1169    /// <p>The list of pipelines.</p>
1170    #[serde(rename = "pipelines")]
1171    #[serde(skip_serializing_if = "Option::is_none")]
1172    pub pipelines: Option<Vec<PipelineSummary>>,
1173}
1174
1175#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1176#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1177pub struct ListTagsForResourceInput {
1178    /// <p>The maximum number of results to return in a single call.</p>
1179    #[serde(rename = "maxResults")]
1180    #[serde(skip_serializing_if = "Option::is_none")]
1181    pub max_results: Option<i64>,
1182    /// <p>The token that was returned from the previous API call, which would be used to return the next page of the list. The ListTagsforResource call lists all available tags in one call and does not use pagination.</p>
1183    #[serde(rename = "nextToken")]
1184    #[serde(skip_serializing_if = "Option::is_none")]
1185    pub next_token: Option<String>,
1186    /// <p>The Amazon Resource Name (ARN) of the resource to get tags for.</p>
1187    #[serde(rename = "resourceArn")]
1188    pub resource_arn: String,
1189}
1190
1191#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1192#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1193pub struct ListTagsForResourceOutput {
1194    /// <p>If the amount of returned information is significantly large, an identifier is also returned and can be used in a subsequent API call to return the next page of the list. The ListTagsforResource call lists all available tags in one call and does not use pagination.</p>
1195    #[serde(rename = "nextToken")]
1196    #[serde(skip_serializing_if = "Option::is_none")]
1197    pub next_token: Option<String>,
1198    /// <p>The tags for the resource.</p>
1199    #[serde(rename = "tags")]
1200    #[serde(skip_serializing_if = "Option::is_none")]
1201    pub tags: Option<Vec<Tag>>,
1202}
1203
1204/// <p>The detail returned for each webhook after listing webhooks, such as the webhook URL, the webhook name, and the webhook ARN.</p>
1205#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1206#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1207pub struct ListWebhookItem {
1208    /// <p>The Amazon Resource Name (ARN) of the webhook.</p>
1209    #[serde(rename = "arn")]
1210    #[serde(skip_serializing_if = "Option::is_none")]
1211    pub arn: Option<String>,
1212    /// <p>The detail returned for each webhook, such as the webhook authentication type and filter rules.</p>
1213    #[serde(rename = "definition")]
1214    pub definition: WebhookDefinition,
1215    /// <p>The number code of the error.</p>
1216    #[serde(rename = "errorCode")]
1217    #[serde(skip_serializing_if = "Option::is_none")]
1218    pub error_code: Option<String>,
1219    /// <p>The text of the error message about the webhook.</p>
1220    #[serde(rename = "errorMessage")]
1221    #[serde(skip_serializing_if = "Option::is_none")]
1222    pub error_message: Option<String>,
1223    /// <p>The date and time a webhook was last successfully triggered, in timestamp format.</p>
1224    #[serde(rename = "lastTriggered")]
1225    #[serde(skip_serializing_if = "Option::is_none")]
1226    pub last_triggered: Option<f64>,
1227    /// <p>Specifies the tags applied to the webhook.</p>
1228    #[serde(rename = "tags")]
1229    #[serde(skip_serializing_if = "Option::is_none")]
1230    pub tags: Option<Vec<Tag>>,
1231    /// <p>A unique URL generated by CodePipeline. When a POST request is made to this URL, the defined pipeline is started as long as the body of the post request satisfies the defined authentication and filtering conditions. Deleting and re-creating a webhook makes the old URL invalid and generates a new one.</p>
1232    #[serde(rename = "url")]
1233    pub url: String,
1234}
1235
1236#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1237#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1238pub struct ListWebhooksInput {
1239    /// <p>The maximum number of results to return in a single call. To retrieve the remaining results, make another call with the returned nextToken value.</p>
1240    #[serde(rename = "MaxResults")]
1241    #[serde(skip_serializing_if = "Option::is_none")]
1242    pub max_results: Option<i64>,
1243    /// <p>The token that was returned from the previous ListWebhooks call, which can be used to return the next set of webhooks in the list.</p>
1244    #[serde(rename = "NextToken")]
1245    #[serde(skip_serializing_if = "Option::is_none")]
1246    pub next_token: Option<String>,
1247}
1248
1249#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1250#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1251pub struct ListWebhooksOutput {
1252    /// <p>If the amount of returned information is significantly large, an identifier is also returned and can be used in a subsequent ListWebhooks call to return the next set of webhooks in the list. </p>
1253    #[serde(rename = "NextToken")]
1254    #[serde(skip_serializing_if = "Option::is_none")]
1255    pub next_token: Option<String>,
1256    /// <p>The JSON detail returned for each webhook in the list output for the ListWebhooks call.</p>
1257    #[serde(rename = "webhooks")]
1258    #[serde(skip_serializing_if = "Option::is_none")]
1259    pub webhooks: Option<Vec<ListWebhookItem>>,
1260}
1261
1262/// <p>Represents information about the output of an action.</p>
1263#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1264pub struct OutputArtifact {
1265    /// <p>The name of the output of an artifact, such as "My App".</p> <p>The input artifact of an action must exactly match the output artifact declared in a preceding action, but the input artifact does not have to be the next action in strict sequence from the action that provided the output artifact. Actions in parallel can declare different output artifacts, which are in turn consumed by different following actions.</p> <p>Output artifact names must be unique within a pipeline.</p>
1266    #[serde(rename = "name")]
1267    pub name: String,
1268}
1269
1270/// <p><p>Represents information about a pipeline to a job worker.</p> <note> <p>PipelineContext contains <code>pipelineArn</code> and <code>pipelineExecutionId</code> for custom action jobs. The <code>pipelineArn</code> and <code>pipelineExecutionId</code> fields are not populated for ThirdParty action jobs.</p> </note></p>
1271#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1272#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1273pub struct PipelineContext {
1274    /// <p>The context of an action to a job worker in the stage of a pipeline.</p>
1275    #[serde(rename = "action")]
1276    #[serde(skip_serializing_if = "Option::is_none")]
1277    pub action: Option<ActionContext>,
1278    /// <p>The Amazon Resource Name (ARN) of the pipeline.</p>
1279    #[serde(rename = "pipelineArn")]
1280    #[serde(skip_serializing_if = "Option::is_none")]
1281    pub pipeline_arn: Option<String>,
1282    /// <p>The execution ID of the pipeline.</p>
1283    #[serde(rename = "pipelineExecutionId")]
1284    #[serde(skip_serializing_if = "Option::is_none")]
1285    pub pipeline_execution_id: Option<String>,
1286    /// <p>The name of the pipeline. This is a user-specified value. Pipeline names must be unique across all pipeline names under an Amazon Web Services account.</p>
1287    #[serde(rename = "pipelineName")]
1288    #[serde(skip_serializing_if = "Option::is_none")]
1289    pub pipeline_name: Option<String>,
1290    /// <p>The stage of the pipeline.</p>
1291    #[serde(rename = "stage")]
1292    #[serde(skip_serializing_if = "Option::is_none")]
1293    pub stage: Option<StageContext>,
1294}
1295
1296/// <p>Represents the structure of actions and stages to be performed in the pipeline.</p>
1297#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1298pub struct PipelineDeclaration {
1299    /// <p><p>Represents information about the S3 bucket where artifacts are stored for the pipeline.</p> <note> <p>You must include either <code>artifactStore</code> or <code>artifactStores</code> in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use <code>artifactStores</code>.</p> </note></p>
1300    #[serde(rename = "artifactStore")]
1301    #[serde(skip_serializing_if = "Option::is_none")]
1302    pub artifact_store: Option<ArtifactStore>,
1303    /// <p><p>A mapping of <code>artifactStore</code> objects and their corresponding AWS Regions. There must be an artifact store for the pipeline Region and for each cross-region action in the pipeline.</p> <note> <p>You must include either <code>artifactStore</code> or <code>artifactStores</code> in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use <code>artifactStores</code>.</p> </note></p>
1304    #[serde(rename = "artifactStores")]
1305    #[serde(skip_serializing_if = "Option::is_none")]
1306    pub artifact_stores: Option<::std::collections::HashMap<String, ArtifactStore>>,
1307    /// <p>The name of the action to be performed.</p>
1308    #[serde(rename = "name")]
1309    pub name: String,
1310    /// <p>The Amazon Resource Name (ARN) for AWS CodePipeline to use to either perform actions with no <code>actionRoleArn</code>, or to use to assume roles for actions with an <code>actionRoleArn</code>.</p>
1311    #[serde(rename = "roleArn")]
1312    pub role_arn: String,
1313    /// <p>The stage in which to perform the action.</p>
1314    #[serde(rename = "stages")]
1315    pub stages: Vec<StageDeclaration>,
1316    /// <p>The version number of the pipeline. A new pipeline always has a version number of 1. This number is incremented when a pipeline is updated.</p>
1317    #[serde(rename = "version")]
1318    #[serde(skip_serializing_if = "Option::is_none")]
1319    pub version: Option<i64>,
1320}
1321
1322/// <p>Represents information about an execution of a pipeline.</p>
1323#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1324#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1325pub struct PipelineExecution {
1326    /// <p>A list of <code>ArtifactRevision</code> objects included in a pipeline execution.</p>
1327    #[serde(rename = "artifactRevisions")]
1328    #[serde(skip_serializing_if = "Option::is_none")]
1329    pub artifact_revisions: Option<Vec<ArtifactRevision>>,
1330    /// <p>The ID of the pipeline execution.</p>
1331    #[serde(rename = "pipelineExecutionId")]
1332    #[serde(skip_serializing_if = "Option::is_none")]
1333    pub pipeline_execution_id: Option<String>,
1334    /// <p>The name of the pipeline with the specified pipeline execution.</p>
1335    #[serde(rename = "pipelineName")]
1336    #[serde(skip_serializing_if = "Option::is_none")]
1337    pub pipeline_name: Option<String>,
1338    /// <p>The version number of the pipeline with the specified pipeline execution.</p>
1339    #[serde(rename = "pipelineVersion")]
1340    #[serde(skip_serializing_if = "Option::is_none")]
1341    pub pipeline_version: Option<i64>,
1342    /// <p><p>The status of the pipeline execution.</p> <ul> <li> <p>InProgress: The pipeline execution is currently running.</p> </li> <li> <p>Stopped: The pipeline execution was manually stopped. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-executions-stopped">Stopped Executions</a>.</p> </li> <li> <p>Stopping: The pipeline execution received a request to be manually stopped. Depending on the selected stop mode, the execution is either completing or abandoning in-progress actions. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-executions-stopped">Stopped Executions</a>.</p> </li> <li> <p>Succeeded: The pipeline execution was completed successfully. </p> </li> <li> <p>Superseded: While this pipeline execution was waiting for the next stage to be completed, a newer pipeline execution advanced and continued through the pipeline instead. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-superseded">Superseded Executions</a>.</p> </li> <li> <p>Failed: The pipeline execution was not completed successfully.</p> </li> </ul></p>
1343    #[serde(rename = "status")]
1344    #[serde(skip_serializing_if = "Option::is_none")]
1345    pub status: Option<String>,
1346}
1347
1348/// <p>Summary information about a pipeline execution.</p>
1349#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1350#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1351pub struct PipelineExecutionSummary {
1352    /// <p>The date and time of the last change to the pipeline execution, in timestamp format.</p>
1353    #[serde(rename = "lastUpdateTime")]
1354    #[serde(skip_serializing_if = "Option::is_none")]
1355    pub last_update_time: Option<f64>,
1356    /// <p>The ID of the pipeline execution.</p>
1357    #[serde(rename = "pipelineExecutionId")]
1358    #[serde(skip_serializing_if = "Option::is_none")]
1359    pub pipeline_execution_id: Option<String>,
1360    /// <p>A list of the source artifact revisions that initiated a pipeline execution.</p>
1361    #[serde(rename = "sourceRevisions")]
1362    #[serde(skip_serializing_if = "Option::is_none")]
1363    pub source_revisions: Option<Vec<SourceRevision>>,
1364    /// <p>The date and time when the pipeline execution began, in timestamp format.</p>
1365    #[serde(rename = "startTime")]
1366    #[serde(skip_serializing_if = "Option::is_none")]
1367    pub start_time: Option<f64>,
1368    /// <p><p>The status of the pipeline execution.</p> <ul> <li> <p>InProgress: The pipeline execution is currently running.</p> </li> <li> <p>Stopped: The pipeline execution was manually stopped. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-executions-stopped">Stopped Executions</a>.</p> </li> <li> <p>Stopping: The pipeline execution received a request to be manually stopped. Depending on the selected stop mode, the execution is either completing or abandoning in-progress actions. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-executions-stopped">Stopped Executions</a>.</p> </li> <li> <p>Succeeded: The pipeline execution was completed successfully. </p> </li> <li> <p>Superseded: While this pipeline execution was waiting for the next stage to be completed, a newer pipeline execution advanced and continued through the pipeline instead. For more information, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-superseded">Superseded Executions</a>.</p> </li> <li> <p>Failed: The pipeline execution was not completed successfully.</p> </li> </ul></p>
1369    #[serde(rename = "status")]
1370    #[serde(skip_serializing_if = "Option::is_none")]
1371    pub status: Option<String>,
1372    /// <p>The interaction that stopped a pipeline execution.</p>
1373    #[serde(rename = "stopTrigger")]
1374    #[serde(skip_serializing_if = "Option::is_none")]
1375    pub stop_trigger: Option<StopExecutionTrigger>,
1376    /// <p>The interaction or event that started a pipeline execution, such as automated change detection or a <code>StartPipelineExecution</code> API call.</p>
1377    #[serde(rename = "trigger")]
1378    #[serde(skip_serializing_if = "Option::is_none")]
1379    pub trigger: Option<ExecutionTrigger>,
1380}
1381
1382/// <p>Information about a pipeline.</p>
1383#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1384#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1385pub struct PipelineMetadata {
1386    /// <p>The date and time the pipeline was created, in timestamp format.</p>
1387    #[serde(rename = "created")]
1388    #[serde(skip_serializing_if = "Option::is_none")]
1389    pub created: Option<f64>,
1390    /// <p>The Amazon Resource Name (ARN) of the pipeline.</p>
1391    #[serde(rename = "pipelineArn")]
1392    #[serde(skip_serializing_if = "Option::is_none")]
1393    pub pipeline_arn: Option<String>,
1394    /// <p>The date and time the pipeline was last updated, in timestamp format.</p>
1395    #[serde(rename = "updated")]
1396    #[serde(skip_serializing_if = "Option::is_none")]
1397    pub updated: Option<f64>,
1398}
1399
1400/// <p>Returns a summary of a pipeline.</p>
1401#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1402#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1403pub struct PipelineSummary {
1404    /// <p>The date and time the pipeline was created, in timestamp format.</p>
1405    #[serde(rename = "created")]
1406    #[serde(skip_serializing_if = "Option::is_none")]
1407    pub created: Option<f64>,
1408    /// <p>The name of the pipeline.</p>
1409    #[serde(rename = "name")]
1410    #[serde(skip_serializing_if = "Option::is_none")]
1411    pub name: Option<String>,
1412    /// <p>The date and time of the last update to the pipeline, in timestamp format.</p>
1413    #[serde(rename = "updated")]
1414    #[serde(skip_serializing_if = "Option::is_none")]
1415    pub updated: Option<f64>,
1416    /// <p>The version number of the pipeline.</p>
1417    #[serde(rename = "version")]
1418    #[serde(skip_serializing_if = "Option::is_none")]
1419    pub version: Option<i64>,
1420}
1421
1422/// <p>Represents the input of a <code>PollForJobs</code> action.</p>
1423#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1424#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1425pub struct PollForJobsInput {
1426    /// <p>Represents information about an action type.</p>
1427    #[serde(rename = "actionTypeId")]
1428    pub action_type_id: ActionTypeId,
1429    /// <p>The maximum number of jobs to return in a poll for jobs call.</p>
1430    #[serde(rename = "maxBatchSize")]
1431    #[serde(skip_serializing_if = "Option::is_none")]
1432    pub max_batch_size: Option<i64>,
1433    /// <p>A map of property names and values. For an action type with no queryable properties, this value must be null or an empty map. For an action type with a queryable property, you must supply that property as a key in the map. Only jobs whose action configuration matches the mapped value are returned.</p>
1434    #[serde(rename = "queryParam")]
1435    #[serde(skip_serializing_if = "Option::is_none")]
1436    pub query_param: Option<::std::collections::HashMap<String, String>>,
1437}
1438
1439/// <p>Represents the output of a <code>PollForJobs</code> action.</p>
1440#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1441#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1442pub struct PollForJobsOutput {
1443    /// <p>Information about the jobs to take action on.</p>
1444    #[serde(rename = "jobs")]
1445    #[serde(skip_serializing_if = "Option::is_none")]
1446    pub jobs: Option<Vec<Job>>,
1447}
1448
1449/// <p>Represents the input of a <code>PollForThirdPartyJobs</code> action.</p>
1450#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1451#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1452pub struct PollForThirdPartyJobsInput {
1453    /// <p>Represents information about an action type.</p>
1454    #[serde(rename = "actionTypeId")]
1455    pub action_type_id: ActionTypeId,
1456    /// <p>The maximum number of jobs to return in a poll for jobs call.</p>
1457    #[serde(rename = "maxBatchSize")]
1458    #[serde(skip_serializing_if = "Option::is_none")]
1459    pub max_batch_size: Option<i64>,
1460}
1461
1462/// <p>Represents the output of a <code>PollForThirdPartyJobs</code> action.</p>
1463#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1464#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1465pub struct PollForThirdPartyJobsOutput {
1466    /// <p>Information about the jobs to take action on.</p>
1467    #[serde(rename = "jobs")]
1468    #[serde(skip_serializing_if = "Option::is_none")]
1469    pub jobs: Option<Vec<ThirdPartyJob>>,
1470}
1471
1472/// <p>Represents the input of a <code>PutActionRevision</code> action.</p>
1473#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1474#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1475pub struct PutActionRevisionInput {
1476    /// <p>The name of the action that processes the revision.</p>
1477    #[serde(rename = "actionName")]
1478    pub action_name: String,
1479    /// <p>Represents information about the version (or revision) of an action.</p>
1480    #[serde(rename = "actionRevision")]
1481    pub action_revision: ActionRevision,
1482    /// <p>The name of the pipeline that starts processing the revision to the source.</p>
1483    #[serde(rename = "pipelineName")]
1484    pub pipeline_name: String,
1485    /// <p>The name of the stage that contains the action that acts on the revision.</p>
1486    #[serde(rename = "stageName")]
1487    pub stage_name: String,
1488}
1489
1490/// <p>Represents the output of a <code>PutActionRevision</code> action.</p>
1491#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1492#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1493pub struct PutActionRevisionOutput {
1494    /// <p>Indicates whether the artifact revision was previously used in an execution of the specified pipeline.</p>
1495    #[serde(rename = "newRevision")]
1496    #[serde(skip_serializing_if = "Option::is_none")]
1497    pub new_revision: Option<bool>,
1498    /// <p>The ID of the current workflow state of the pipeline.</p>
1499    #[serde(rename = "pipelineExecutionId")]
1500    #[serde(skip_serializing_if = "Option::is_none")]
1501    pub pipeline_execution_id: Option<String>,
1502}
1503
1504/// <p>Represents the input of a <code>PutApprovalResult</code> action.</p>
1505#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1506#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1507pub struct PutApprovalResultInput {
1508    /// <p>The name of the action for which approval is requested.</p>
1509    #[serde(rename = "actionName")]
1510    pub action_name: String,
1511    /// <p>The name of the pipeline that contains the action. </p>
1512    #[serde(rename = "pipelineName")]
1513    pub pipeline_name: String,
1514    /// <p>Represents information about the result of the approval request.</p>
1515    #[serde(rename = "result")]
1516    pub result: ApprovalResult,
1517    /// <p>The name of the stage that contains the action.</p>
1518    #[serde(rename = "stageName")]
1519    pub stage_name: String,
1520    /// <p>The system-generated token used to identify a unique approval request. The token for each open approval request can be obtained using the <a>GetPipelineState</a> action. It is used to validate that the approval request corresponding to this token is still valid.</p>
1521    #[serde(rename = "token")]
1522    pub token: String,
1523}
1524
1525/// <p>Represents the output of a <code>PutApprovalResult</code> action.</p>
1526#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1527#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1528pub struct PutApprovalResultOutput {
1529    /// <p>The timestamp showing when the approval or rejection was submitted.</p>
1530    #[serde(rename = "approvedAt")]
1531    #[serde(skip_serializing_if = "Option::is_none")]
1532    pub approved_at: Option<f64>,
1533}
1534
1535/// <p>Represents the input of a <code>PutJobFailureResult</code> action.</p>
1536#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1537#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1538pub struct PutJobFailureResultInput {
1539    /// <p>The details about the failure of a job.</p>
1540    #[serde(rename = "failureDetails")]
1541    pub failure_details: FailureDetails,
1542    /// <p>The unique system-generated ID of the job that failed. This is the same ID returned from <code>PollForJobs</code>.</p>
1543    #[serde(rename = "jobId")]
1544    pub job_id: String,
1545}
1546
1547/// <p>Represents the input of a <code>PutJobSuccessResult</code> action.</p>
1548#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1549#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1550pub struct PutJobSuccessResultInput {
1551    /// <p>A token generated by a job worker, such as an AWS CodeDeploy deployment ID, that a successful job provides to identify a custom action in progress. Future jobs use this token to identify the running instance of the action. It can be reused to return more information about the progress of the custom action. When the action is complete, no continuation token should be supplied.</p>
1552    #[serde(rename = "continuationToken")]
1553    #[serde(skip_serializing_if = "Option::is_none")]
1554    pub continuation_token: Option<String>,
1555    /// <p>The ID of the current revision of the artifact successfully worked on by the job.</p>
1556    #[serde(rename = "currentRevision")]
1557    #[serde(skip_serializing_if = "Option::is_none")]
1558    pub current_revision: Option<CurrentRevision>,
1559    /// <p>The execution details of the successful job, such as the actions taken by the job worker.</p>
1560    #[serde(rename = "executionDetails")]
1561    #[serde(skip_serializing_if = "Option::is_none")]
1562    pub execution_details: Option<ExecutionDetails>,
1563    /// <p>The unique system-generated ID of the job that succeeded. This is the same ID returned from <code>PollForJobs</code>.</p>
1564    #[serde(rename = "jobId")]
1565    pub job_id: String,
1566    /// <p>Key-value pairs produced as output by a job worker that can be made available to a downstream action configuration. <code>outputVariables</code> can be included only when there is no continuation token on the request.</p>
1567    #[serde(rename = "outputVariables")]
1568    #[serde(skip_serializing_if = "Option::is_none")]
1569    pub output_variables: Option<::std::collections::HashMap<String, String>>,
1570}
1571
1572/// <p>Represents the input of a <code>PutThirdPartyJobFailureResult</code> action.</p>
1573#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1574#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1575pub struct PutThirdPartyJobFailureResultInput {
1576    /// <p>The clientToken portion of the clientId and clientToken pair used to verify that the calling entity is allowed access to the job and its details.</p>
1577    #[serde(rename = "clientToken")]
1578    pub client_token: String,
1579    /// <p>Represents information about failure details.</p>
1580    #[serde(rename = "failureDetails")]
1581    pub failure_details: FailureDetails,
1582    /// <p>The ID of the job that failed. This is the same ID returned from <code>PollForThirdPartyJobs</code>.</p>
1583    #[serde(rename = "jobId")]
1584    pub job_id: String,
1585}
1586
1587/// <p>Represents the input of a <code>PutThirdPartyJobSuccessResult</code> action.</p>
1588#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1589#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1590pub struct PutThirdPartyJobSuccessResultInput {
1591    /// <p>The clientToken portion of the clientId and clientToken pair used to verify that the calling entity is allowed access to the job and its details.</p>
1592    #[serde(rename = "clientToken")]
1593    pub client_token: String,
1594    /// <p>A token generated by a job worker, such as an AWS CodeDeploy deployment ID, that a successful job provides to identify a partner action in progress. Future jobs use this token to identify the running instance of the action. It can be reused to return more information about the progress of the partner action. When the action is complete, no continuation token should be supplied.</p>
1595    #[serde(rename = "continuationToken")]
1596    #[serde(skip_serializing_if = "Option::is_none")]
1597    pub continuation_token: Option<String>,
1598    /// <p>Represents information about a current revision.</p>
1599    #[serde(rename = "currentRevision")]
1600    #[serde(skip_serializing_if = "Option::is_none")]
1601    pub current_revision: Option<CurrentRevision>,
1602    /// <p>The details of the actions taken and results produced on an artifact as it passes through stages in the pipeline. </p>
1603    #[serde(rename = "executionDetails")]
1604    #[serde(skip_serializing_if = "Option::is_none")]
1605    pub execution_details: Option<ExecutionDetails>,
1606    /// <p>The ID of the job that successfully completed. This is the same ID returned from <code>PollForThirdPartyJobs</code>.</p>
1607    #[serde(rename = "jobId")]
1608    pub job_id: String,
1609}
1610
1611#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1612#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1613pub struct PutWebhookInput {
1614    /// <p>The tags for the webhook.</p>
1615    #[serde(rename = "tags")]
1616    #[serde(skip_serializing_if = "Option::is_none")]
1617    pub tags: Option<Vec<Tag>>,
1618    /// <p>The detail provided in an input file to create the webhook, such as the webhook name, the pipeline name, and the action name. Give the webhook a unique name that helps you identify it. You might name the webhook after the pipeline and action it targets so that you can easily recognize what it's used for later.</p>
1619    #[serde(rename = "webhook")]
1620    pub webhook: WebhookDefinition,
1621}
1622
1623#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1624#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1625pub struct PutWebhookOutput {
1626    /// <p>The detail returned from creating the webhook, such as the webhook name, webhook URL, and webhook ARN.</p>
1627    #[serde(rename = "webhook")]
1628    #[serde(skip_serializing_if = "Option::is_none")]
1629    pub webhook: Option<ListWebhookItem>,
1630}
1631
1632#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1633#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1634pub struct RegisterWebhookWithThirdPartyInput {
1635    /// <p>The name of an existing webhook created with PutWebhook to register with a supported third party. </p>
1636    #[serde(rename = "webhookName")]
1637    #[serde(skip_serializing_if = "Option::is_none")]
1638    pub webhook_name: Option<String>,
1639}
1640
1641#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1642#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1643pub struct RegisterWebhookWithThirdPartyOutput {}
1644
1645/// <p>Represents the input of a <code>RetryStageExecution</code> action.</p>
1646#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1647#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1648pub struct RetryStageExecutionInput {
1649    /// <p>The ID of the pipeline execution in the failed stage to be retried. Use the <a>GetPipelineState</a> action to retrieve the current pipelineExecutionId of the failed stage</p>
1650    #[serde(rename = "pipelineExecutionId")]
1651    pub pipeline_execution_id: String,
1652    /// <p>The name of the pipeline that contains the failed stage.</p>
1653    #[serde(rename = "pipelineName")]
1654    pub pipeline_name: String,
1655    /// <p>The scope of the retry attempt. Currently, the only supported value is FAILED_ACTIONS.</p>
1656    #[serde(rename = "retryMode")]
1657    pub retry_mode: String,
1658    /// <p>The name of the failed stage to be retried.</p>
1659    #[serde(rename = "stageName")]
1660    pub stage_name: String,
1661}
1662
1663/// <p>Represents the output of a <code>RetryStageExecution</code> action.</p>
1664#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1665#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1666pub struct RetryStageExecutionOutput {
1667    /// <p>The ID of the current workflow execution in the failed stage.</p>
1668    #[serde(rename = "pipelineExecutionId")]
1669    #[serde(skip_serializing_if = "Option::is_none")]
1670    pub pipeline_execution_id: Option<String>,
1671}
1672
1673/// <p>The location of the S3 bucket that contains a revision.</p>
1674#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1675#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1676pub struct S3ArtifactLocation {
1677    /// <p>The name of the S3 bucket.</p>
1678    #[serde(rename = "bucketName")]
1679    pub bucket_name: String,
1680    /// <p>The key of the object in the S3 bucket, which uniquely identifies the object in the bucket.</p>
1681    #[serde(rename = "objectKey")]
1682    pub object_key: String,
1683}
1684
1685/// <p>The Amazon S3 artifact location for an action's artifacts.</p>
1686#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1687#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1688pub struct S3Location {
1689    /// <p>The Amazon S3 artifact bucket for an action's artifacts.</p>
1690    #[serde(rename = "bucket")]
1691    #[serde(skip_serializing_if = "Option::is_none")]
1692    pub bucket: Option<String>,
1693    /// <p>The artifact name.</p>
1694    #[serde(rename = "key")]
1695    #[serde(skip_serializing_if = "Option::is_none")]
1696    pub key: Option<String>,
1697}
1698
1699/// <p>Information about the version (or revision) of a source artifact that initiated a pipeline execution.</p>
1700#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1701#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1702pub struct SourceRevision {
1703    /// <p>The name of the action that processed the revision to the source artifact.</p>
1704    #[serde(rename = "actionName")]
1705    pub action_name: String,
1706    /// <p>The system-generated unique ID that identifies the revision number of the artifact.</p>
1707    #[serde(rename = "revisionId")]
1708    #[serde(skip_serializing_if = "Option::is_none")]
1709    pub revision_id: Option<String>,
1710    /// <p>Summary information about the most recent revision of the artifact. For GitHub and AWS CodeCommit repositories, the commit message. For Amazon S3 buckets or actions, the user-provided content of a <code>codepipeline-artifact-revision-summary</code> key specified in the object metadata.</p>
1711    #[serde(rename = "revisionSummary")]
1712    #[serde(skip_serializing_if = "Option::is_none")]
1713    pub revision_summary: Option<String>,
1714    /// <p>The commit ID for the artifact revision. For artifacts stored in GitHub or AWS CodeCommit repositories, the commit ID is linked to a commit details page.</p>
1715    #[serde(rename = "revisionUrl")]
1716    #[serde(skip_serializing_if = "Option::is_none")]
1717    pub revision_url: Option<String>,
1718}
1719
1720/// <p>Represents information about a stage to a job worker.</p>
1721#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1722#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1723pub struct StageContext {
1724    /// <p>The name of the stage.</p>
1725    #[serde(rename = "name")]
1726    #[serde(skip_serializing_if = "Option::is_none")]
1727    pub name: Option<String>,
1728}
1729
1730/// <p>Represents information about a stage and its definition.</p>
1731#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1732pub struct StageDeclaration {
1733    /// <p>The actions included in a stage.</p>
1734    #[serde(rename = "actions")]
1735    pub actions: Vec<ActionDeclaration>,
1736    /// <p>Reserved for future use.</p>
1737    #[serde(rename = "blockers")]
1738    #[serde(skip_serializing_if = "Option::is_none")]
1739    pub blockers: Option<Vec<BlockerDeclaration>>,
1740    /// <p>The name of the stage.</p>
1741    #[serde(rename = "name")]
1742    pub name: String,
1743}
1744
1745/// <p>Represents information about the run of a stage.</p>
1746#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1747#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1748pub struct StageExecution {
1749    /// <p>The ID of the pipeline execution associated with the stage.</p>
1750    #[serde(rename = "pipelineExecutionId")]
1751    pub pipeline_execution_id: String,
1752    /// <p>The status of the stage, or for a completed stage, the last status of the stage.</p>
1753    #[serde(rename = "status")]
1754    pub status: String,
1755}
1756
1757/// <p>Represents information about the state of the stage.</p>
1758#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1759#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1760pub struct StageState {
1761    /// <p>The state of the stage.</p>
1762    #[serde(rename = "actionStates")]
1763    #[serde(skip_serializing_if = "Option::is_none")]
1764    pub action_states: Option<Vec<ActionState>>,
1765    /// <p>The state of the inbound transition, which is either enabled or disabled.</p>
1766    #[serde(rename = "inboundTransitionState")]
1767    #[serde(skip_serializing_if = "Option::is_none")]
1768    pub inbound_transition_state: Option<TransitionState>,
1769    /// <p>Information about the latest execution in the stage, including its ID and status.</p>
1770    #[serde(rename = "latestExecution")]
1771    #[serde(skip_serializing_if = "Option::is_none")]
1772    pub latest_execution: Option<StageExecution>,
1773    /// <p>The name of the stage.</p>
1774    #[serde(rename = "stageName")]
1775    #[serde(skip_serializing_if = "Option::is_none")]
1776    pub stage_name: Option<String>,
1777}
1778
1779/// <p>Represents the input of a <code>StartPipelineExecution</code> action.</p>
1780#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1781#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1782pub struct StartPipelineExecutionInput {
1783    /// <p>The system-generated unique ID used to identify a unique execution request.</p>
1784    #[serde(rename = "clientRequestToken")]
1785    #[serde(skip_serializing_if = "Option::is_none")]
1786    pub client_request_token: Option<String>,
1787    /// <p>The name of the pipeline to start.</p>
1788    #[serde(rename = "name")]
1789    pub name: String,
1790}
1791
1792/// <p>Represents the output of a <code>StartPipelineExecution</code> action.</p>
1793#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1794#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1795pub struct StartPipelineExecutionOutput {
1796    /// <p>The unique system-generated ID of the pipeline execution that was started.</p>
1797    #[serde(rename = "pipelineExecutionId")]
1798    #[serde(skip_serializing_if = "Option::is_none")]
1799    pub pipeline_execution_id: Option<String>,
1800}
1801
1802/// <p>The interaction that stopped a pipeline execution.</p>
1803#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1804#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1805pub struct StopExecutionTrigger {
1806    /// <p>The user-specified reason the pipeline was stopped.</p>
1807    #[serde(rename = "reason")]
1808    #[serde(skip_serializing_if = "Option::is_none")]
1809    pub reason: Option<String>,
1810}
1811
1812#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1813#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1814pub struct StopPipelineExecutionInput {
1815    /// <p><p>Use this option to stop the pipeline execution by abandoning, rather than finishing, in-progress actions.</p> <note> <p>This option can lead to failed or out-of-sequence tasks.</p> </note></p>
1816    #[serde(rename = "abandon")]
1817    #[serde(skip_serializing_if = "Option::is_none")]
1818    pub abandon: Option<bool>,
1819    /// <p>The ID of the pipeline execution to be stopped in the current stage. Use the <code>GetPipelineState</code> action to retrieve the current pipelineExecutionId.</p>
1820    #[serde(rename = "pipelineExecutionId")]
1821    pub pipeline_execution_id: String,
1822    /// <p>The name of the pipeline to stop.</p>
1823    #[serde(rename = "pipelineName")]
1824    pub pipeline_name: String,
1825    /// <p>Use this option to enter comments, such as the reason the pipeline was stopped.</p>
1826    #[serde(rename = "reason")]
1827    #[serde(skip_serializing_if = "Option::is_none")]
1828    pub reason: Option<String>,
1829}
1830
1831#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1832#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1833pub struct StopPipelineExecutionOutput {
1834    /// <p>The unique system-generated ID of the pipeline execution that was stopped.</p>
1835    #[serde(rename = "pipelineExecutionId")]
1836    #[serde(skip_serializing_if = "Option::is_none")]
1837    pub pipeline_execution_id: Option<String>,
1838}
1839
1840/// <p>A tag is a key-value pair that is used to manage the resource.</p>
1841#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1842pub struct Tag {
1843    /// <p>The tag's key.</p>
1844    #[serde(rename = "key")]
1845    pub key: String,
1846    /// <p>The tag's value.</p>
1847    #[serde(rename = "value")]
1848    pub value: String,
1849}
1850
1851#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1852#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1853pub struct TagResourceInput {
1854    /// <p>The Amazon Resource Name (ARN) of the resource you want to add tags to.</p>
1855    #[serde(rename = "resourceArn")]
1856    pub resource_arn: String,
1857    /// <p>The tags you want to modify or add to the resource.</p>
1858    #[serde(rename = "tags")]
1859    pub tags: Vec<Tag>,
1860}
1861
1862#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1863#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1864pub struct TagResourceOutput {}
1865
1866/// <p>A response to a <code>PollForThirdPartyJobs</code> request returned by AWS CodePipeline when there is a job to be worked on by a partner action.</p>
1867#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1868#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1869pub struct ThirdPartyJob {
1870    /// <p>The <code>clientToken</code> portion of the <code>clientId</code> and <code>clientToken</code> pair used to verify that the calling entity is allowed access to the job and its details.</p>
1871    #[serde(rename = "clientId")]
1872    #[serde(skip_serializing_if = "Option::is_none")]
1873    pub client_id: Option<String>,
1874    /// <p>The identifier used to identify the job in AWS CodePipeline.</p>
1875    #[serde(rename = "jobId")]
1876    #[serde(skip_serializing_if = "Option::is_none")]
1877    pub job_id: Option<String>,
1878}
1879
1880/// <p>Represents information about the job data for a partner action.</p>
1881#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1882#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1883pub struct ThirdPartyJobData {
1884    /// <p>Represents information about an action configuration.</p>
1885    #[serde(rename = "actionConfiguration")]
1886    #[serde(skip_serializing_if = "Option::is_none")]
1887    pub action_configuration: Option<ActionConfiguration>,
1888    /// <p>Represents information about an action type.</p>
1889    #[serde(rename = "actionTypeId")]
1890    #[serde(skip_serializing_if = "Option::is_none")]
1891    pub action_type_id: Option<ActionTypeId>,
1892    /// <p>Represents an AWS session credentials object. These credentials are temporary credentials that are issued by AWS Secure Token Service (STS). They can be used to access input and output artifacts in the S3 bucket used to store artifact for the pipeline in AWS CodePipeline. </p>
1893    #[serde(rename = "artifactCredentials")]
1894    #[serde(skip_serializing_if = "Option::is_none")]
1895    pub artifact_credentials: Option<AWSSessionCredentials>,
1896    /// <p>A system-generated token, such as a AWS CodeDeploy deployment ID, that a job requires to continue the job asynchronously.</p>
1897    #[serde(rename = "continuationToken")]
1898    #[serde(skip_serializing_if = "Option::is_none")]
1899    pub continuation_token: Option<String>,
1900    /// <p>The encryption key used to encrypt and decrypt data in the artifact store for the pipeline, such as an AWS Key Management Service (AWS KMS) key. This is optional and might not be present.</p>
1901    #[serde(rename = "encryptionKey")]
1902    #[serde(skip_serializing_if = "Option::is_none")]
1903    pub encryption_key: Option<EncryptionKey>,
1904    /// <p>The name of the artifact that is worked on by the action, if any. This name might be system-generated, such as "MyApp", or it might be defined by the user when the action is created. The input artifact name must match the name of an output artifact generated by an action in an earlier action or stage of the pipeline.</p>
1905    #[serde(rename = "inputArtifacts")]
1906    #[serde(skip_serializing_if = "Option::is_none")]
1907    pub input_artifacts: Option<Vec<Artifact>>,
1908    /// <p>The name of the artifact that is the result of the action, if any. This name might be system-generated, such as "MyBuiltApp", or it might be defined by the user when the action is created.</p>
1909    #[serde(rename = "outputArtifacts")]
1910    #[serde(skip_serializing_if = "Option::is_none")]
1911    pub output_artifacts: Option<Vec<Artifact>>,
1912    /// <p><p>Represents information about a pipeline to a job worker.</p> <note> <p>Does not include <code>pipelineArn</code> and <code>pipelineExecutionId</code> for ThirdParty jobs.</p> </note></p>
1913    #[serde(rename = "pipelineContext")]
1914    #[serde(skip_serializing_if = "Option::is_none")]
1915    pub pipeline_context: Option<PipelineContext>,
1916}
1917
1918/// <p>The details of a job sent in response to a <code>GetThirdPartyJobDetails</code> request.</p>
1919#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1920#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1921pub struct ThirdPartyJobDetails {
1922    /// <p>The data to be returned by the third party job worker.</p>
1923    #[serde(rename = "data")]
1924    #[serde(skip_serializing_if = "Option::is_none")]
1925    pub data: Option<ThirdPartyJobData>,
1926    /// <p>The identifier used to identify the job details in AWS CodePipeline.</p>
1927    #[serde(rename = "id")]
1928    #[serde(skip_serializing_if = "Option::is_none")]
1929    pub id: Option<String>,
1930    /// <p>A system-generated random number that AWS CodePipeline uses to ensure that the job is being worked on by only one job worker. Use this number in an <a>AcknowledgeThirdPartyJob</a> request.</p>
1931    #[serde(rename = "nonce")]
1932    #[serde(skip_serializing_if = "Option::is_none")]
1933    pub nonce: Option<String>,
1934}
1935
1936/// <p>Represents information about the state of transitions between one stage and another stage.</p>
1937#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1938#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1939pub struct TransitionState {
1940    /// <p>The user-specified reason why the transition between two stages of a pipeline was disabled.</p>
1941    #[serde(rename = "disabledReason")]
1942    #[serde(skip_serializing_if = "Option::is_none")]
1943    pub disabled_reason: Option<String>,
1944    /// <p>Whether the transition between stages is enabled (true) or disabled (false).</p>
1945    #[serde(rename = "enabled")]
1946    #[serde(skip_serializing_if = "Option::is_none")]
1947    pub enabled: Option<bool>,
1948    /// <p>The timestamp when the transition state was last changed.</p>
1949    #[serde(rename = "lastChangedAt")]
1950    #[serde(skip_serializing_if = "Option::is_none")]
1951    pub last_changed_at: Option<f64>,
1952    /// <p>The ID of the user who last changed the transition state.</p>
1953    #[serde(rename = "lastChangedBy")]
1954    #[serde(skip_serializing_if = "Option::is_none")]
1955    pub last_changed_by: Option<String>,
1956}
1957
1958#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1959#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1960pub struct UntagResourceInput {
1961    /// <p> The Amazon Resource Name (ARN) of the resource to remove tags from.</p>
1962    #[serde(rename = "resourceArn")]
1963    pub resource_arn: String,
1964    /// <p>The list of keys for the tags to be removed from the resource.</p>
1965    #[serde(rename = "tagKeys")]
1966    pub tag_keys: Vec<String>,
1967}
1968
1969#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1970#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1971pub struct UntagResourceOutput {}
1972
1973/// <p>Represents the input of an <code>UpdatePipeline</code> action.</p>
1974#[derive(Clone, Debug, Default, PartialEq, Serialize)]
1975#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
1976pub struct UpdatePipelineInput {
1977    /// <p>The name of the pipeline to be updated.</p>
1978    #[serde(rename = "pipeline")]
1979    pub pipeline: PipelineDeclaration,
1980}
1981
1982/// <p>Represents the output of an <code>UpdatePipeline</code> action.</p>
1983#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
1984#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
1985pub struct UpdatePipelineOutput {
1986    /// <p>The structure of the updated pipeline.</p>
1987    #[serde(rename = "pipeline")]
1988    #[serde(skip_serializing_if = "Option::is_none")]
1989    pub pipeline: Option<PipelineDeclaration>,
1990}
1991
1992/// <p>The authentication applied to incoming webhook trigger requests.</p>
1993#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
1994pub struct WebhookAuthConfiguration {
1995    /// <p>The property used to configure acceptance of webhooks in an IP address range. For IP, only the <code>AllowedIPRange</code> property must be set. This property must be set to a valid CIDR range.</p>
1996    #[serde(rename = "AllowedIPRange")]
1997    #[serde(skip_serializing_if = "Option::is_none")]
1998    pub allowed_ip_range: Option<String>,
1999    /// <p>The property used to configure GitHub authentication. For GITHUB_HMAC, only the <code>SecretToken</code> property must be set.</p>
2000    #[serde(rename = "SecretToken")]
2001    #[serde(skip_serializing_if = "Option::is_none")]
2002    pub secret_token: Option<String>,
2003}
2004
2005/// <p>Represents information about a webhook and its definition.</p>
2006#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
2007pub struct WebhookDefinition {
2008    /// <p><p>Supported options are GITHUB<em>HMAC, IP, and UNAUTHENTICATED.</p> <ul> <li> <p>For information about the authentication scheme implemented by GITHUB</em>HMAC, see <a href="https://developer.github.com/webhooks/securing/">Securing your webhooks</a> on the GitHub Developer website.</p> </li> <li> <p> IP rejects webhooks trigger requests unless they originate from an IP address in the IP range whitelisted in the authentication configuration.</p> </li> <li> <p> UNAUTHENTICATED accepts all webhook trigger requests regardless of origin.</p> </li> </ul></p>
2009    #[serde(rename = "authentication")]
2010    pub authentication: String,
2011    /// <p>Properties that configure the authentication applied to incoming webhook trigger requests. The required properties depend on the authentication type. For GITHUB_HMAC, only the <code>SecretToken </code>property must be set. For IP, only the <code>AllowedIPRange </code>property must be set to a valid CIDR range. For UNAUTHENTICATED, no properties can be set.</p>
2012    #[serde(rename = "authenticationConfiguration")]
2013    pub authentication_configuration: WebhookAuthConfiguration,
2014    /// <p>A list of rules applied to the body/payload sent in the POST request to a webhook URL. All defined rules must pass for the request to be accepted and the pipeline started.</p>
2015    #[serde(rename = "filters")]
2016    pub filters: Vec<WebhookFilterRule>,
2017    /// <p>The name of the webhook.</p>
2018    #[serde(rename = "name")]
2019    pub name: String,
2020    /// <p>The name of the action in a pipeline you want to connect to the webhook. The action must be from the source (first) stage of the pipeline.</p>
2021    #[serde(rename = "targetAction")]
2022    pub target_action: String,
2023    /// <p>The name of the pipeline you want to connect to the webhook.</p>
2024    #[serde(rename = "targetPipeline")]
2025    pub target_pipeline: String,
2026}
2027
2028/// <p>The event criteria that specify when a webhook notification is sent to your URL.</p>
2029#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
2030pub struct WebhookFilterRule {
2031    /// <p>A JsonPath expression that is applied to the body/payload of the webhook. The value selected by the JsonPath expression must match the value specified in the <code>MatchEquals</code> field. Otherwise, the request is ignored. For more information, see <a href="https://github.com/json-path/JsonPath">Java JsonPath implementation</a> in GitHub.</p>
2032    #[serde(rename = "jsonPath")]
2033    pub json_path: String,
2034    /// <p>The value selected by the <code>JsonPath</code> expression must match what is supplied in the <code>MatchEquals</code> field. Otherwise, the request is ignored. Properties from the target action configuration can be included as placeholders in this value by surrounding the action configuration key with curly brackets. For example, if the value supplied here is "refs/heads/{Branch}" and the target action has an action configuration property called "Branch" with a value of "master", the <code>MatchEquals</code> value is evaluated as "refs/heads/master". For a list of action configuration properties for built-in action types, see <a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements">Pipeline Structure Reference Action Requirements</a>.</p>
2035    #[serde(rename = "matchEquals")]
2036    #[serde(skip_serializing_if = "Option::is_none")]
2037    pub match_equals: Option<String>,
2038}
2039
2040/// Errors returned by AcknowledgeJob
2041#[derive(Debug, PartialEq)]
2042pub enum AcknowledgeJobError {
2043    /// <p>The nonce was specified in an invalid format.</p>
2044    InvalidNonce(String),
2045    /// <p>The job was specified in an invalid format or cannot be found.</p>
2046    JobNotFound(String),
2047}
2048
2049impl AcknowledgeJobError {
2050    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AcknowledgeJobError> {
2051        if let Some(err) = proto::json::Error::parse(&res) {
2052            match err.typ.as_str() {
2053                "InvalidNonceException" => {
2054                    return RusotoError::Service(AcknowledgeJobError::InvalidNonce(err.msg))
2055                }
2056                "JobNotFoundException" => {
2057                    return RusotoError::Service(AcknowledgeJobError::JobNotFound(err.msg))
2058                }
2059                "ValidationException" => return RusotoError::Validation(err.msg),
2060                _ => {}
2061            }
2062        }
2063        RusotoError::Unknown(res)
2064    }
2065}
2066impl fmt::Display for AcknowledgeJobError {
2067    #[allow(unused_variables)]
2068    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2069        match *self {
2070            AcknowledgeJobError::InvalidNonce(ref cause) => write!(f, "{}", cause),
2071            AcknowledgeJobError::JobNotFound(ref cause) => write!(f, "{}", cause),
2072        }
2073    }
2074}
2075impl Error for AcknowledgeJobError {}
2076/// Errors returned by AcknowledgeThirdPartyJob
2077#[derive(Debug, PartialEq)]
2078pub enum AcknowledgeThirdPartyJobError {
2079    /// <p>The client token was specified in an invalid format</p>
2080    InvalidClientToken(String),
2081    /// <p>The nonce was specified in an invalid format.</p>
2082    InvalidNonce(String),
2083    /// <p>The job was specified in an invalid format or cannot be found.</p>
2084    JobNotFound(String),
2085}
2086
2087impl AcknowledgeThirdPartyJobError {
2088    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AcknowledgeThirdPartyJobError> {
2089        if let Some(err) = proto::json::Error::parse(&res) {
2090            match err.typ.as_str() {
2091                "InvalidClientTokenException" => {
2092                    return RusotoError::Service(AcknowledgeThirdPartyJobError::InvalidClientToken(
2093                        err.msg,
2094                    ))
2095                }
2096                "InvalidNonceException" => {
2097                    return RusotoError::Service(AcknowledgeThirdPartyJobError::InvalidNonce(
2098                        err.msg,
2099                    ))
2100                }
2101                "JobNotFoundException" => {
2102                    return RusotoError::Service(AcknowledgeThirdPartyJobError::JobNotFound(
2103                        err.msg,
2104                    ))
2105                }
2106                "ValidationException" => return RusotoError::Validation(err.msg),
2107                _ => {}
2108            }
2109        }
2110        RusotoError::Unknown(res)
2111    }
2112}
2113impl fmt::Display for AcknowledgeThirdPartyJobError {
2114    #[allow(unused_variables)]
2115    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2116        match *self {
2117            AcknowledgeThirdPartyJobError::InvalidClientToken(ref cause) => write!(f, "{}", cause),
2118            AcknowledgeThirdPartyJobError::InvalidNonce(ref cause) => write!(f, "{}", cause),
2119            AcknowledgeThirdPartyJobError::JobNotFound(ref cause) => write!(f, "{}", cause),
2120        }
2121    }
2122}
2123impl Error for AcknowledgeThirdPartyJobError {}
2124/// Errors returned by CreateCustomActionType
2125#[derive(Debug, PartialEq)]
2126pub enum CreateCustomActionTypeError {
2127    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
2128    ConcurrentModification(String),
2129    /// <p>The specified resource tags are invalid.</p>
2130    InvalidTags(String),
2131    /// <p>The number of pipelines associated with the AWS account has exceeded the limit allowed for the account.</p>
2132    LimitExceeded(String),
2133    /// <p>The tags limit for a resource has been exceeded.</p>
2134    TooManyTags(String),
2135}
2136
2137impl CreateCustomActionTypeError {
2138    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCustomActionTypeError> {
2139        if let Some(err) = proto::json::Error::parse(&res) {
2140            match err.typ.as_str() {
2141                "ConcurrentModificationException" => {
2142                    return RusotoError::Service(
2143                        CreateCustomActionTypeError::ConcurrentModification(err.msg),
2144                    )
2145                }
2146                "InvalidTagsException" => {
2147                    return RusotoError::Service(CreateCustomActionTypeError::InvalidTags(err.msg))
2148                }
2149                "LimitExceededException" => {
2150                    return RusotoError::Service(CreateCustomActionTypeError::LimitExceeded(
2151                        err.msg,
2152                    ))
2153                }
2154                "TooManyTagsException" => {
2155                    return RusotoError::Service(CreateCustomActionTypeError::TooManyTags(err.msg))
2156                }
2157                "ValidationException" => return RusotoError::Validation(err.msg),
2158                _ => {}
2159            }
2160        }
2161        RusotoError::Unknown(res)
2162    }
2163}
2164impl fmt::Display for CreateCustomActionTypeError {
2165    #[allow(unused_variables)]
2166    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2167        match *self {
2168            CreateCustomActionTypeError::ConcurrentModification(ref cause) => {
2169                write!(f, "{}", cause)
2170            }
2171            CreateCustomActionTypeError::InvalidTags(ref cause) => write!(f, "{}", cause),
2172            CreateCustomActionTypeError::LimitExceeded(ref cause) => write!(f, "{}", cause),
2173            CreateCustomActionTypeError::TooManyTags(ref cause) => write!(f, "{}", cause),
2174        }
2175    }
2176}
2177impl Error for CreateCustomActionTypeError {}
2178/// Errors returned by CreatePipeline
2179#[derive(Debug, PartialEq)]
2180pub enum CreatePipelineError {
2181    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
2182    ConcurrentModification(String),
2183    /// <p>The action declaration was specified in an invalid format.</p>
2184    InvalidActionDeclaration(String),
2185    /// <p>Reserved for future use.</p>
2186    InvalidBlockerDeclaration(String),
2187    /// <p>The stage declaration was specified in an invalid format.</p>
2188    InvalidStageDeclaration(String),
2189    /// <p>The structure was specified in an invalid format.</p>
2190    InvalidStructure(String),
2191    /// <p>The specified resource tags are invalid.</p>
2192    InvalidTags(String),
2193    /// <p>The number of pipelines associated with the AWS account has exceeded the limit allowed for the account.</p>
2194    LimitExceeded(String),
2195    /// <p>The specified pipeline name is already in use.</p>
2196    PipelineNameInUse(String),
2197    /// <p>The tags limit for a resource has been exceeded.</p>
2198    TooManyTags(String),
2199}
2200
2201impl CreatePipelineError {
2202    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePipelineError> {
2203        if let Some(err) = proto::json::Error::parse(&res) {
2204            match err.typ.as_str() {
2205                "ConcurrentModificationException" => {
2206                    return RusotoError::Service(CreatePipelineError::ConcurrentModification(
2207                        err.msg,
2208                    ))
2209                }
2210                "InvalidActionDeclarationException" => {
2211                    return RusotoError::Service(CreatePipelineError::InvalidActionDeclaration(
2212                        err.msg,
2213                    ))
2214                }
2215                "InvalidBlockerDeclarationException" => {
2216                    return RusotoError::Service(CreatePipelineError::InvalidBlockerDeclaration(
2217                        err.msg,
2218                    ))
2219                }
2220                "InvalidStageDeclarationException" => {
2221                    return RusotoError::Service(CreatePipelineError::InvalidStageDeclaration(
2222                        err.msg,
2223                    ))
2224                }
2225                "InvalidStructureException" => {
2226                    return RusotoError::Service(CreatePipelineError::InvalidStructure(err.msg))
2227                }
2228                "InvalidTagsException" => {
2229                    return RusotoError::Service(CreatePipelineError::InvalidTags(err.msg))
2230                }
2231                "LimitExceededException" => {
2232                    return RusotoError::Service(CreatePipelineError::LimitExceeded(err.msg))
2233                }
2234                "PipelineNameInUseException" => {
2235                    return RusotoError::Service(CreatePipelineError::PipelineNameInUse(err.msg))
2236                }
2237                "TooManyTagsException" => {
2238                    return RusotoError::Service(CreatePipelineError::TooManyTags(err.msg))
2239                }
2240                "ValidationException" => return RusotoError::Validation(err.msg),
2241                _ => {}
2242            }
2243        }
2244        RusotoError::Unknown(res)
2245    }
2246}
2247impl fmt::Display for CreatePipelineError {
2248    #[allow(unused_variables)]
2249    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2250        match *self {
2251            CreatePipelineError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
2252            CreatePipelineError::InvalidActionDeclaration(ref cause) => write!(f, "{}", cause),
2253            CreatePipelineError::InvalidBlockerDeclaration(ref cause) => write!(f, "{}", cause),
2254            CreatePipelineError::InvalidStageDeclaration(ref cause) => write!(f, "{}", cause),
2255            CreatePipelineError::InvalidStructure(ref cause) => write!(f, "{}", cause),
2256            CreatePipelineError::InvalidTags(ref cause) => write!(f, "{}", cause),
2257            CreatePipelineError::LimitExceeded(ref cause) => write!(f, "{}", cause),
2258            CreatePipelineError::PipelineNameInUse(ref cause) => write!(f, "{}", cause),
2259            CreatePipelineError::TooManyTags(ref cause) => write!(f, "{}", cause),
2260        }
2261    }
2262}
2263impl Error for CreatePipelineError {}
2264/// Errors returned by DeleteCustomActionType
2265#[derive(Debug, PartialEq)]
2266pub enum DeleteCustomActionTypeError {
2267    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
2268    ConcurrentModification(String),
2269}
2270
2271impl DeleteCustomActionTypeError {
2272    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCustomActionTypeError> {
2273        if let Some(err) = proto::json::Error::parse(&res) {
2274            match err.typ.as_str() {
2275                "ConcurrentModificationException" => {
2276                    return RusotoError::Service(
2277                        DeleteCustomActionTypeError::ConcurrentModification(err.msg),
2278                    )
2279                }
2280                "ValidationException" => return RusotoError::Validation(err.msg),
2281                _ => {}
2282            }
2283        }
2284        RusotoError::Unknown(res)
2285    }
2286}
2287impl fmt::Display for DeleteCustomActionTypeError {
2288    #[allow(unused_variables)]
2289    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2290        match *self {
2291            DeleteCustomActionTypeError::ConcurrentModification(ref cause) => {
2292                write!(f, "{}", cause)
2293            }
2294        }
2295    }
2296}
2297impl Error for DeleteCustomActionTypeError {}
2298/// Errors returned by DeletePipeline
2299#[derive(Debug, PartialEq)]
2300pub enum DeletePipelineError {
2301    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
2302    ConcurrentModification(String),
2303}
2304
2305impl DeletePipelineError {
2306    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePipelineError> {
2307        if let Some(err) = proto::json::Error::parse(&res) {
2308            match err.typ.as_str() {
2309                "ConcurrentModificationException" => {
2310                    return RusotoError::Service(DeletePipelineError::ConcurrentModification(
2311                        err.msg,
2312                    ))
2313                }
2314                "ValidationException" => return RusotoError::Validation(err.msg),
2315                _ => {}
2316            }
2317        }
2318        RusotoError::Unknown(res)
2319    }
2320}
2321impl fmt::Display for DeletePipelineError {
2322    #[allow(unused_variables)]
2323    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2324        match *self {
2325            DeletePipelineError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
2326        }
2327    }
2328}
2329impl Error for DeletePipelineError {}
2330/// Errors returned by DeleteWebhook
2331#[derive(Debug, PartialEq)]
2332pub enum DeleteWebhookError {
2333    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
2334    ConcurrentModification(String),
2335}
2336
2337impl DeleteWebhookError {
2338    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWebhookError> {
2339        if let Some(err) = proto::json::Error::parse(&res) {
2340            match err.typ.as_str() {
2341                "ConcurrentModificationException" => {
2342                    return RusotoError::Service(DeleteWebhookError::ConcurrentModification(
2343                        err.msg,
2344                    ))
2345                }
2346                "ValidationException" => return RusotoError::Validation(err.msg),
2347                _ => {}
2348            }
2349        }
2350        RusotoError::Unknown(res)
2351    }
2352}
2353impl fmt::Display for DeleteWebhookError {
2354    #[allow(unused_variables)]
2355    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2356        match *self {
2357            DeleteWebhookError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
2358        }
2359    }
2360}
2361impl Error for DeleteWebhookError {}
2362/// Errors returned by DeregisterWebhookWithThirdParty
2363#[derive(Debug, PartialEq)]
2364pub enum DeregisterWebhookWithThirdPartyError {
2365    /// <p>The specified webhook was entered in an invalid format or cannot be found.</p>
2366    WebhookNotFound(String),
2367}
2368
2369impl DeregisterWebhookWithThirdPartyError {
2370    pub fn from_response(
2371        res: BufferedHttpResponse,
2372    ) -> RusotoError<DeregisterWebhookWithThirdPartyError> {
2373        if let Some(err) = proto::json::Error::parse(&res) {
2374            match err.typ.as_str() {
2375                "WebhookNotFoundException" => {
2376                    return RusotoError::Service(
2377                        DeregisterWebhookWithThirdPartyError::WebhookNotFound(err.msg),
2378                    )
2379                }
2380                "ValidationException" => return RusotoError::Validation(err.msg),
2381                _ => {}
2382            }
2383        }
2384        RusotoError::Unknown(res)
2385    }
2386}
2387impl fmt::Display for DeregisterWebhookWithThirdPartyError {
2388    #[allow(unused_variables)]
2389    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2390        match *self {
2391            DeregisterWebhookWithThirdPartyError::WebhookNotFound(ref cause) => {
2392                write!(f, "{}", cause)
2393            }
2394        }
2395    }
2396}
2397impl Error for DeregisterWebhookWithThirdPartyError {}
2398/// Errors returned by DisableStageTransition
2399#[derive(Debug, PartialEq)]
2400pub enum DisableStageTransitionError {
2401    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2402    PipelineNotFound(String),
2403    /// <p>The stage was specified in an invalid format or cannot be found.</p>
2404    StageNotFound(String),
2405}
2406
2407impl DisableStageTransitionError {
2408    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableStageTransitionError> {
2409        if let Some(err) = proto::json::Error::parse(&res) {
2410            match err.typ.as_str() {
2411                "PipelineNotFoundException" => {
2412                    return RusotoError::Service(DisableStageTransitionError::PipelineNotFound(
2413                        err.msg,
2414                    ))
2415                }
2416                "StageNotFoundException" => {
2417                    return RusotoError::Service(DisableStageTransitionError::StageNotFound(
2418                        err.msg,
2419                    ))
2420                }
2421                "ValidationException" => return RusotoError::Validation(err.msg),
2422                _ => {}
2423            }
2424        }
2425        RusotoError::Unknown(res)
2426    }
2427}
2428impl fmt::Display for DisableStageTransitionError {
2429    #[allow(unused_variables)]
2430    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2431        match *self {
2432            DisableStageTransitionError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2433            DisableStageTransitionError::StageNotFound(ref cause) => write!(f, "{}", cause),
2434        }
2435    }
2436}
2437impl Error for DisableStageTransitionError {}
2438/// Errors returned by EnableStageTransition
2439#[derive(Debug, PartialEq)]
2440pub enum EnableStageTransitionError {
2441    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2442    PipelineNotFound(String),
2443    /// <p>The stage was specified in an invalid format or cannot be found.</p>
2444    StageNotFound(String),
2445}
2446
2447impl EnableStageTransitionError {
2448    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableStageTransitionError> {
2449        if let Some(err) = proto::json::Error::parse(&res) {
2450            match err.typ.as_str() {
2451                "PipelineNotFoundException" => {
2452                    return RusotoError::Service(EnableStageTransitionError::PipelineNotFound(
2453                        err.msg,
2454                    ))
2455                }
2456                "StageNotFoundException" => {
2457                    return RusotoError::Service(EnableStageTransitionError::StageNotFound(err.msg))
2458                }
2459                "ValidationException" => return RusotoError::Validation(err.msg),
2460                _ => {}
2461            }
2462        }
2463        RusotoError::Unknown(res)
2464    }
2465}
2466impl fmt::Display for EnableStageTransitionError {
2467    #[allow(unused_variables)]
2468    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2469        match *self {
2470            EnableStageTransitionError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2471            EnableStageTransitionError::StageNotFound(ref cause) => write!(f, "{}", cause),
2472        }
2473    }
2474}
2475impl Error for EnableStageTransitionError {}
2476/// Errors returned by GetJobDetails
2477#[derive(Debug, PartialEq)]
2478pub enum GetJobDetailsError {
2479    /// <p>The job was specified in an invalid format or cannot be found.</p>
2480    JobNotFound(String),
2481}
2482
2483impl GetJobDetailsError {
2484    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetJobDetailsError> {
2485        if let Some(err) = proto::json::Error::parse(&res) {
2486            match err.typ.as_str() {
2487                "JobNotFoundException" => {
2488                    return RusotoError::Service(GetJobDetailsError::JobNotFound(err.msg))
2489                }
2490                "ValidationException" => return RusotoError::Validation(err.msg),
2491                _ => {}
2492            }
2493        }
2494        RusotoError::Unknown(res)
2495    }
2496}
2497impl fmt::Display for GetJobDetailsError {
2498    #[allow(unused_variables)]
2499    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2500        match *self {
2501            GetJobDetailsError::JobNotFound(ref cause) => write!(f, "{}", cause),
2502        }
2503    }
2504}
2505impl Error for GetJobDetailsError {}
2506/// Errors returned by GetPipeline
2507#[derive(Debug, PartialEq)]
2508pub enum GetPipelineError {
2509    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2510    PipelineNotFound(String),
2511    /// <p>The pipeline version was specified in an invalid format or cannot be found.</p>
2512    PipelineVersionNotFound(String),
2513}
2514
2515impl GetPipelineError {
2516    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPipelineError> {
2517        if let Some(err) = proto::json::Error::parse(&res) {
2518            match err.typ.as_str() {
2519                "PipelineNotFoundException" => {
2520                    return RusotoError::Service(GetPipelineError::PipelineNotFound(err.msg))
2521                }
2522                "PipelineVersionNotFoundException" => {
2523                    return RusotoError::Service(GetPipelineError::PipelineVersionNotFound(err.msg))
2524                }
2525                "ValidationException" => return RusotoError::Validation(err.msg),
2526                _ => {}
2527            }
2528        }
2529        RusotoError::Unknown(res)
2530    }
2531}
2532impl fmt::Display for GetPipelineError {
2533    #[allow(unused_variables)]
2534    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2535        match *self {
2536            GetPipelineError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2537            GetPipelineError::PipelineVersionNotFound(ref cause) => write!(f, "{}", cause),
2538        }
2539    }
2540}
2541impl Error for GetPipelineError {}
2542/// Errors returned by GetPipelineExecution
2543#[derive(Debug, PartialEq)]
2544pub enum GetPipelineExecutionError {
2545    /// <p>The pipeline execution was specified in an invalid format or cannot be found, or an execution ID does not belong to the specified pipeline. </p>
2546    PipelineExecutionNotFound(String),
2547    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2548    PipelineNotFound(String),
2549}
2550
2551impl GetPipelineExecutionError {
2552    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPipelineExecutionError> {
2553        if let Some(err) = proto::json::Error::parse(&res) {
2554            match err.typ.as_str() {
2555                "PipelineExecutionNotFoundException" => {
2556                    return RusotoError::Service(
2557                        GetPipelineExecutionError::PipelineExecutionNotFound(err.msg),
2558                    )
2559                }
2560                "PipelineNotFoundException" => {
2561                    return RusotoError::Service(GetPipelineExecutionError::PipelineNotFound(
2562                        err.msg,
2563                    ))
2564                }
2565                "ValidationException" => return RusotoError::Validation(err.msg),
2566                _ => {}
2567            }
2568        }
2569        RusotoError::Unknown(res)
2570    }
2571}
2572impl fmt::Display for GetPipelineExecutionError {
2573    #[allow(unused_variables)]
2574    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2575        match *self {
2576            GetPipelineExecutionError::PipelineExecutionNotFound(ref cause) => {
2577                write!(f, "{}", cause)
2578            }
2579            GetPipelineExecutionError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2580        }
2581    }
2582}
2583impl Error for GetPipelineExecutionError {}
2584/// Errors returned by GetPipelineState
2585#[derive(Debug, PartialEq)]
2586pub enum GetPipelineStateError {
2587    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2588    PipelineNotFound(String),
2589}
2590
2591impl GetPipelineStateError {
2592    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPipelineStateError> {
2593        if let Some(err) = proto::json::Error::parse(&res) {
2594            match err.typ.as_str() {
2595                "PipelineNotFoundException" => {
2596                    return RusotoError::Service(GetPipelineStateError::PipelineNotFound(err.msg))
2597                }
2598                "ValidationException" => return RusotoError::Validation(err.msg),
2599                _ => {}
2600            }
2601        }
2602        RusotoError::Unknown(res)
2603    }
2604}
2605impl fmt::Display for GetPipelineStateError {
2606    #[allow(unused_variables)]
2607    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2608        match *self {
2609            GetPipelineStateError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2610        }
2611    }
2612}
2613impl Error for GetPipelineStateError {}
2614/// Errors returned by GetThirdPartyJobDetails
2615#[derive(Debug, PartialEq)]
2616pub enum GetThirdPartyJobDetailsError {
2617    /// <p>The client token was specified in an invalid format</p>
2618    InvalidClientToken(String),
2619    /// <p>The job was specified in an invalid format or cannot be found.</p>
2620    InvalidJob(String),
2621    /// <p>The job was specified in an invalid format or cannot be found.</p>
2622    JobNotFound(String),
2623}
2624
2625impl GetThirdPartyJobDetailsError {
2626    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetThirdPartyJobDetailsError> {
2627        if let Some(err) = proto::json::Error::parse(&res) {
2628            match err.typ.as_str() {
2629                "InvalidClientTokenException" => {
2630                    return RusotoError::Service(GetThirdPartyJobDetailsError::InvalidClientToken(
2631                        err.msg,
2632                    ))
2633                }
2634                "InvalidJobException" => {
2635                    return RusotoError::Service(GetThirdPartyJobDetailsError::InvalidJob(err.msg))
2636                }
2637                "JobNotFoundException" => {
2638                    return RusotoError::Service(GetThirdPartyJobDetailsError::JobNotFound(err.msg))
2639                }
2640                "ValidationException" => return RusotoError::Validation(err.msg),
2641                _ => {}
2642            }
2643        }
2644        RusotoError::Unknown(res)
2645    }
2646}
2647impl fmt::Display for GetThirdPartyJobDetailsError {
2648    #[allow(unused_variables)]
2649    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2650        match *self {
2651            GetThirdPartyJobDetailsError::InvalidClientToken(ref cause) => write!(f, "{}", cause),
2652            GetThirdPartyJobDetailsError::InvalidJob(ref cause) => write!(f, "{}", cause),
2653            GetThirdPartyJobDetailsError::JobNotFound(ref cause) => write!(f, "{}", cause),
2654        }
2655    }
2656}
2657impl Error for GetThirdPartyJobDetailsError {}
2658/// Errors returned by ListActionExecutions
2659#[derive(Debug, PartialEq)]
2660pub enum ListActionExecutionsError {
2661    /// <p>The next token was specified in an invalid format. Make sure that the next token you provide is the token returned by a previous call.</p>
2662    InvalidNextToken(String),
2663    /// <p>The pipeline execution was specified in an invalid format or cannot be found, or an execution ID does not belong to the specified pipeline. </p>
2664    PipelineExecutionNotFound(String),
2665    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2666    PipelineNotFound(String),
2667}
2668
2669impl ListActionExecutionsError {
2670    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListActionExecutionsError> {
2671        if let Some(err) = proto::json::Error::parse(&res) {
2672            match err.typ.as_str() {
2673                "InvalidNextTokenException" => {
2674                    return RusotoError::Service(ListActionExecutionsError::InvalidNextToken(
2675                        err.msg,
2676                    ))
2677                }
2678                "PipelineExecutionNotFoundException" => {
2679                    return RusotoError::Service(
2680                        ListActionExecutionsError::PipelineExecutionNotFound(err.msg),
2681                    )
2682                }
2683                "PipelineNotFoundException" => {
2684                    return RusotoError::Service(ListActionExecutionsError::PipelineNotFound(
2685                        err.msg,
2686                    ))
2687                }
2688                "ValidationException" => return RusotoError::Validation(err.msg),
2689                _ => {}
2690            }
2691        }
2692        RusotoError::Unknown(res)
2693    }
2694}
2695impl fmt::Display for ListActionExecutionsError {
2696    #[allow(unused_variables)]
2697    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2698        match *self {
2699            ListActionExecutionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
2700            ListActionExecutionsError::PipelineExecutionNotFound(ref cause) => {
2701                write!(f, "{}", cause)
2702            }
2703            ListActionExecutionsError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2704        }
2705    }
2706}
2707impl Error for ListActionExecutionsError {}
2708/// Errors returned by ListActionTypes
2709#[derive(Debug, PartialEq)]
2710pub enum ListActionTypesError {
2711    /// <p>The next token was specified in an invalid format. Make sure that the next token you provide is the token returned by a previous call.</p>
2712    InvalidNextToken(String),
2713}
2714
2715impl ListActionTypesError {
2716    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListActionTypesError> {
2717        if let Some(err) = proto::json::Error::parse(&res) {
2718            match err.typ.as_str() {
2719                "InvalidNextTokenException" => {
2720                    return RusotoError::Service(ListActionTypesError::InvalidNextToken(err.msg))
2721                }
2722                "ValidationException" => return RusotoError::Validation(err.msg),
2723                _ => {}
2724            }
2725        }
2726        RusotoError::Unknown(res)
2727    }
2728}
2729impl fmt::Display for ListActionTypesError {
2730    #[allow(unused_variables)]
2731    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2732        match *self {
2733            ListActionTypesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
2734        }
2735    }
2736}
2737impl Error for ListActionTypesError {}
2738/// Errors returned by ListPipelineExecutions
2739#[derive(Debug, PartialEq)]
2740pub enum ListPipelineExecutionsError {
2741    /// <p>The next token was specified in an invalid format. Make sure that the next token you provide is the token returned by a previous call.</p>
2742    InvalidNextToken(String),
2743    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2744    PipelineNotFound(String),
2745}
2746
2747impl ListPipelineExecutionsError {
2748    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPipelineExecutionsError> {
2749        if let Some(err) = proto::json::Error::parse(&res) {
2750            match err.typ.as_str() {
2751                "InvalidNextTokenException" => {
2752                    return RusotoError::Service(ListPipelineExecutionsError::InvalidNextToken(
2753                        err.msg,
2754                    ))
2755                }
2756                "PipelineNotFoundException" => {
2757                    return RusotoError::Service(ListPipelineExecutionsError::PipelineNotFound(
2758                        err.msg,
2759                    ))
2760                }
2761                "ValidationException" => return RusotoError::Validation(err.msg),
2762                _ => {}
2763            }
2764        }
2765        RusotoError::Unknown(res)
2766    }
2767}
2768impl fmt::Display for ListPipelineExecutionsError {
2769    #[allow(unused_variables)]
2770    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2771        match *self {
2772            ListPipelineExecutionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
2773            ListPipelineExecutionsError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2774        }
2775    }
2776}
2777impl Error for ListPipelineExecutionsError {}
2778/// Errors returned by ListPipelines
2779#[derive(Debug, PartialEq)]
2780pub enum ListPipelinesError {
2781    /// <p>The next token was specified in an invalid format. Make sure that the next token you provide is the token returned by a previous call.</p>
2782    InvalidNextToken(String),
2783}
2784
2785impl ListPipelinesError {
2786    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPipelinesError> {
2787        if let Some(err) = proto::json::Error::parse(&res) {
2788            match err.typ.as_str() {
2789                "InvalidNextTokenException" => {
2790                    return RusotoError::Service(ListPipelinesError::InvalidNextToken(err.msg))
2791                }
2792                "ValidationException" => return RusotoError::Validation(err.msg),
2793                _ => {}
2794            }
2795        }
2796        RusotoError::Unknown(res)
2797    }
2798}
2799impl fmt::Display for ListPipelinesError {
2800    #[allow(unused_variables)]
2801    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2802        match *self {
2803            ListPipelinesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
2804        }
2805    }
2806}
2807impl Error for ListPipelinesError {}
2808/// Errors returned by ListTagsForResource
2809#[derive(Debug, PartialEq)]
2810pub enum ListTagsForResourceError {
2811    /// <p>The specified resource ARN is invalid.</p>
2812    InvalidArn(String),
2813    /// <p>The next token was specified in an invalid format. Make sure that the next token you provide is the token returned by a previous call.</p>
2814    InvalidNextToken(String),
2815    /// <p>The resource was specified in an invalid format.</p>
2816    ResourceNotFound(String),
2817}
2818
2819impl ListTagsForResourceError {
2820    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
2821        if let Some(err) = proto::json::Error::parse(&res) {
2822            match err.typ.as_str() {
2823                "InvalidArnException" => {
2824                    return RusotoError::Service(ListTagsForResourceError::InvalidArn(err.msg))
2825                }
2826                "InvalidNextTokenException" => {
2827                    return RusotoError::Service(ListTagsForResourceError::InvalidNextToken(
2828                        err.msg,
2829                    ))
2830                }
2831                "ResourceNotFoundException" => {
2832                    return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
2833                        err.msg,
2834                    ))
2835                }
2836                "ValidationException" => return RusotoError::Validation(err.msg),
2837                _ => {}
2838            }
2839        }
2840        RusotoError::Unknown(res)
2841    }
2842}
2843impl fmt::Display for ListTagsForResourceError {
2844    #[allow(unused_variables)]
2845    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2846        match *self {
2847            ListTagsForResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
2848            ListTagsForResourceError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
2849            ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
2850        }
2851    }
2852}
2853impl Error for ListTagsForResourceError {}
2854/// Errors returned by ListWebhooks
2855#[derive(Debug, PartialEq)]
2856pub enum ListWebhooksError {
2857    /// <p>The next token was specified in an invalid format. Make sure that the next token you provide is the token returned by a previous call.</p>
2858    InvalidNextToken(String),
2859}
2860
2861impl ListWebhooksError {
2862    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWebhooksError> {
2863        if let Some(err) = proto::json::Error::parse(&res) {
2864            match err.typ.as_str() {
2865                "InvalidNextTokenException" => {
2866                    return RusotoError::Service(ListWebhooksError::InvalidNextToken(err.msg))
2867                }
2868                "ValidationException" => return RusotoError::Validation(err.msg),
2869                _ => {}
2870            }
2871        }
2872        RusotoError::Unknown(res)
2873    }
2874}
2875impl fmt::Display for ListWebhooksError {
2876    #[allow(unused_variables)]
2877    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2878        match *self {
2879            ListWebhooksError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
2880        }
2881    }
2882}
2883impl Error for ListWebhooksError {}
2884/// Errors returned by PollForJobs
2885#[derive(Debug, PartialEq)]
2886pub enum PollForJobsError {
2887    /// <p>The specified action type cannot be found.</p>
2888    ActionTypeNotFound(String),
2889}
2890
2891impl PollForJobsError {
2892    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PollForJobsError> {
2893        if let Some(err) = proto::json::Error::parse(&res) {
2894            match err.typ.as_str() {
2895                "ActionTypeNotFoundException" => {
2896                    return RusotoError::Service(PollForJobsError::ActionTypeNotFound(err.msg))
2897                }
2898                "ValidationException" => return RusotoError::Validation(err.msg),
2899                _ => {}
2900            }
2901        }
2902        RusotoError::Unknown(res)
2903    }
2904}
2905impl fmt::Display for PollForJobsError {
2906    #[allow(unused_variables)]
2907    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2908        match *self {
2909            PollForJobsError::ActionTypeNotFound(ref cause) => write!(f, "{}", cause),
2910        }
2911    }
2912}
2913impl Error for PollForJobsError {}
2914/// Errors returned by PollForThirdPartyJobs
2915#[derive(Debug, PartialEq)]
2916pub enum PollForThirdPartyJobsError {
2917    /// <p>The specified action type cannot be found.</p>
2918    ActionTypeNotFound(String),
2919}
2920
2921impl PollForThirdPartyJobsError {
2922    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PollForThirdPartyJobsError> {
2923        if let Some(err) = proto::json::Error::parse(&res) {
2924            match err.typ.as_str() {
2925                "ActionTypeNotFoundException" => {
2926                    return RusotoError::Service(PollForThirdPartyJobsError::ActionTypeNotFound(
2927                        err.msg,
2928                    ))
2929                }
2930                "ValidationException" => return RusotoError::Validation(err.msg),
2931                _ => {}
2932            }
2933        }
2934        RusotoError::Unknown(res)
2935    }
2936}
2937impl fmt::Display for PollForThirdPartyJobsError {
2938    #[allow(unused_variables)]
2939    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2940        match *self {
2941            PollForThirdPartyJobsError::ActionTypeNotFound(ref cause) => write!(f, "{}", cause),
2942        }
2943    }
2944}
2945impl Error for PollForThirdPartyJobsError {}
2946/// Errors returned by PutActionRevision
2947#[derive(Debug, PartialEq)]
2948pub enum PutActionRevisionError {
2949    /// <p>The specified action cannot be found.</p>
2950    ActionNotFound(String),
2951    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2952    PipelineNotFound(String),
2953    /// <p>The stage was specified in an invalid format or cannot be found.</p>
2954    StageNotFound(String),
2955}
2956
2957impl PutActionRevisionError {
2958    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutActionRevisionError> {
2959        if let Some(err) = proto::json::Error::parse(&res) {
2960            match err.typ.as_str() {
2961                "ActionNotFoundException" => {
2962                    return RusotoError::Service(PutActionRevisionError::ActionNotFound(err.msg))
2963                }
2964                "PipelineNotFoundException" => {
2965                    return RusotoError::Service(PutActionRevisionError::PipelineNotFound(err.msg))
2966                }
2967                "StageNotFoundException" => {
2968                    return RusotoError::Service(PutActionRevisionError::StageNotFound(err.msg))
2969                }
2970                "ValidationException" => return RusotoError::Validation(err.msg),
2971                _ => {}
2972            }
2973        }
2974        RusotoError::Unknown(res)
2975    }
2976}
2977impl fmt::Display for PutActionRevisionError {
2978    #[allow(unused_variables)]
2979    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2980        match *self {
2981            PutActionRevisionError::ActionNotFound(ref cause) => write!(f, "{}", cause),
2982            PutActionRevisionError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
2983            PutActionRevisionError::StageNotFound(ref cause) => write!(f, "{}", cause),
2984        }
2985    }
2986}
2987impl Error for PutActionRevisionError {}
2988/// Errors returned by PutApprovalResult
2989#[derive(Debug, PartialEq)]
2990pub enum PutApprovalResultError {
2991    /// <p>The specified action cannot be found.</p>
2992    ActionNotFound(String),
2993    /// <p>The approval action has already been approved or rejected.</p>
2994    ApprovalAlreadyCompleted(String),
2995    /// <p>The approval request already received a response or has expired.</p>
2996    InvalidApprovalToken(String),
2997    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
2998    PipelineNotFound(String),
2999    /// <p>The stage was specified in an invalid format or cannot be found.</p>
3000    StageNotFound(String),
3001}
3002
3003impl PutApprovalResultError {
3004    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutApprovalResultError> {
3005        if let Some(err) = proto::json::Error::parse(&res) {
3006            match err.typ.as_str() {
3007                "ActionNotFoundException" => {
3008                    return RusotoError::Service(PutApprovalResultError::ActionNotFound(err.msg))
3009                }
3010                "ApprovalAlreadyCompletedException" => {
3011                    return RusotoError::Service(PutApprovalResultError::ApprovalAlreadyCompleted(
3012                        err.msg,
3013                    ))
3014                }
3015                "InvalidApprovalTokenException" => {
3016                    return RusotoError::Service(PutApprovalResultError::InvalidApprovalToken(
3017                        err.msg,
3018                    ))
3019                }
3020                "PipelineNotFoundException" => {
3021                    return RusotoError::Service(PutApprovalResultError::PipelineNotFound(err.msg))
3022                }
3023                "StageNotFoundException" => {
3024                    return RusotoError::Service(PutApprovalResultError::StageNotFound(err.msg))
3025                }
3026                "ValidationException" => return RusotoError::Validation(err.msg),
3027                _ => {}
3028            }
3029        }
3030        RusotoError::Unknown(res)
3031    }
3032}
3033impl fmt::Display for PutApprovalResultError {
3034    #[allow(unused_variables)]
3035    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3036        match *self {
3037            PutApprovalResultError::ActionNotFound(ref cause) => write!(f, "{}", cause),
3038            PutApprovalResultError::ApprovalAlreadyCompleted(ref cause) => write!(f, "{}", cause),
3039            PutApprovalResultError::InvalidApprovalToken(ref cause) => write!(f, "{}", cause),
3040            PutApprovalResultError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
3041            PutApprovalResultError::StageNotFound(ref cause) => write!(f, "{}", cause),
3042        }
3043    }
3044}
3045impl Error for PutApprovalResultError {}
3046/// Errors returned by PutJobFailureResult
3047#[derive(Debug, PartialEq)]
3048pub enum PutJobFailureResultError {
3049    /// <p>The job state was specified in an invalid format.</p>
3050    InvalidJobState(String),
3051    /// <p>The job was specified in an invalid format or cannot be found.</p>
3052    JobNotFound(String),
3053}
3054
3055impl PutJobFailureResultError {
3056    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutJobFailureResultError> {
3057        if let Some(err) = proto::json::Error::parse(&res) {
3058            match err.typ.as_str() {
3059                "InvalidJobStateException" => {
3060                    return RusotoError::Service(PutJobFailureResultError::InvalidJobState(err.msg))
3061                }
3062                "JobNotFoundException" => {
3063                    return RusotoError::Service(PutJobFailureResultError::JobNotFound(err.msg))
3064                }
3065                "ValidationException" => return RusotoError::Validation(err.msg),
3066                _ => {}
3067            }
3068        }
3069        RusotoError::Unknown(res)
3070    }
3071}
3072impl fmt::Display for PutJobFailureResultError {
3073    #[allow(unused_variables)]
3074    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3075        match *self {
3076            PutJobFailureResultError::InvalidJobState(ref cause) => write!(f, "{}", cause),
3077            PutJobFailureResultError::JobNotFound(ref cause) => write!(f, "{}", cause),
3078        }
3079    }
3080}
3081impl Error for PutJobFailureResultError {}
3082/// Errors returned by PutJobSuccessResult
3083#[derive(Debug, PartialEq)]
3084pub enum PutJobSuccessResultError {
3085    /// <p>The job state was specified in an invalid format.</p>
3086    InvalidJobState(String),
3087    /// <p>The job was specified in an invalid format or cannot be found.</p>
3088    JobNotFound(String),
3089    /// <p>Exceeded the total size limit for all variables in the pipeline.</p>
3090    OutputVariablesSizeExceeded(String),
3091}
3092
3093impl PutJobSuccessResultError {
3094    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutJobSuccessResultError> {
3095        if let Some(err) = proto::json::Error::parse(&res) {
3096            match err.typ.as_str() {
3097                "InvalidJobStateException" => {
3098                    return RusotoError::Service(PutJobSuccessResultError::InvalidJobState(err.msg))
3099                }
3100                "JobNotFoundException" => {
3101                    return RusotoError::Service(PutJobSuccessResultError::JobNotFound(err.msg))
3102                }
3103                "OutputVariablesSizeExceededException" => {
3104                    return RusotoError::Service(
3105                        PutJobSuccessResultError::OutputVariablesSizeExceeded(err.msg),
3106                    )
3107                }
3108                "ValidationException" => return RusotoError::Validation(err.msg),
3109                _ => {}
3110            }
3111        }
3112        RusotoError::Unknown(res)
3113    }
3114}
3115impl fmt::Display for PutJobSuccessResultError {
3116    #[allow(unused_variables)]
3117    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3118        match *self {
3119            PutJobSuccessResultError::InvalidJobState(ref cause) => write!(f, "{}", cause),
3120            PutJobSuccessResultError::JobNotFound(ref cause) => write!(f, "{}", cause),
3121            PutJobSuccessResultError::OutputVariablesSizeExceeded(ref cause) => {
3122                write!(f, "{}", cause)
3123            }
3124        }
3125    }
3126}
3127impl Error for PutJobSuccessResultError {}
3128/// Errors returned by PutThirdPartyJobFailureResult
3129#[derive(Debug, PartialEq)]
3130pub enum PutThirdPartyJobFailureResultError {
3131    /// <p>The client token was specified in an invalid format</p>
3132    InvalidClientToken(String),
3133    /// <p>The job state was specified in an invalid format.</p>
3134    InvalidJobState(String),
3135    /// <p>The job was specified in an invalid format or cannot be found.</p>
3136    JobNotFound(String),
3137}
3138
3139impl PutThirdPartyJobFailureResultError {
3140    pub fn from_response(
3141        res: BufferedHttpResponse,
3142    ) -> RusotoError<PutThirdPartyJobFailureResultError> {
3143        if let Some(err) = proto::json::Error::parse(&res) {
3144            match err.typ.as_str() {
3145                "InvalidClientTokenException" => {
3146                    return RusotoError::Service(
3147                        PutThirdPartyJobFailureResultError::InvalidClientToken(err.msg),
3148                    )
3149                }
3150                "InvalidJobStateException" => {
3151                    return RusotoError::Service(
3152                        PutThirdPartyJobFailureResultError::InvalidJobState(err.msg),
3153                    )
3154                }
3155                "JobNotFoundException" => {
3156                    return RusotoError::Service(PutThirdPartyJobFailureResultError::JobNotFound(
3157                        err.msg,
3158                    ))
3159                }
3160                "ValidationException" => return RusotoError::Validation(err.msg),
3161                _ => {}
3162            }
3163        }
3164        RusotoError::Unknown(res)
3165    }
3166}
3167impl fmt::Display for PutThirdPartyJobFailureResultError {
3168    #[allow(unused_variables)]
3169    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3170        match *self {
3171            PutThirdPartyJobFailureResultError::InvalidClientToken(ref cause) => {
3172                write!(f, "{}", cause)
3173            }
3174            PutThirdPartyJobFailureResultError::InvalidJobState(ref cause) => {
3175                write!(f, "{}", cause)
3176            }
3177            PutThirdPartyJobFailureResultError::JobNotFound(ref cause) => write!(f, "{}", cause),
3178        }
3179    }
3180}
3181impl Error for PutThirdPartyJobFailureResultError {}
3182/// Errors returned by PutThirdPartyJobSuccessResult
3183#[derive(Debug, PartialEq)]
3184pub enum PutThirdPartyJobSuccessResultError {
3185    /// <p>The client token was specified in an invalid format</p>
3186    InvalidClientToken(String),
3187    /// <p>The job state was specified in an invalid format.</p>
3188    InvalidJobState(String),
3189    /// <p>The job was specified in an invalid format or cannot be found.</p>
3190    JobNotFound(String),
3191}
3192
3193impl PutThirdPartyJobSuccessResultError {
3194    pub fn from_response(
3195        res: BufferedHttpResponse,
3196    ) -> RusotoError<PutThirdPartyJobSuccessResultError> {
3197        if let Some(err) = proto::json::Error::parse(&res) {
3198            match err.typ.as_str() {
3199                "InvalidClientTokenException" => {
3200                    return RusotoError::Service(
3201                        PutThirdPartyJobSuccessResultError::InvalidClientToken(err.msg),
3202                    )
3203                }
3204                "InvalidJobStateException" => {
3205                    return RusotoError::Service(
3206                        PutThirdPartyJobSuccessResultError::InvalidJobState(err.msg),
3207                    )
3208                }
3209                "JobNotFoundException" => {
3210                    return RusotoError::Service(PutThirdPartyJobSuccessResultError::JobNotFound(
3211                        err.msg,
3212                    ))
3213                }
3214                "ValidationException" => return RusotoError::Validation(err.msg),
3215                _ => {}
3216            }
3217        }
3218        RusotoError::Unknown(res)
3219    }
3220}
3221impl fmt::Display for PutThirdPartyJobSuccessResultError {
3222    #[allow(unused_variables)]
3223    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3224        match *self {
3225            PutThirdPartyJobSuccessResultError::InvalidClientToken(ref cause) => {
3226                write!(f, "{}", cause)
3227            }
3228            PutThirdPartyJobSuccessResultError::InvalidJobState(ref cause) => {
3229                write!(f, "{}", cause)
3230            }
3231            PutThirdPartyJobSuccessResultError::JobNotFound(ref cause) => write!(f, "{}", cause),
3232        }
3233    }
3234}
3235impl Error for PutThirdPartyJobSuccessResultError {}
3236/// Errors returned by PutWebhook
3237#[derive(Debug, PartialEq)]
3238pub enum PutWebhookError {
3239    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
3240    ConcurrentModification(String),
3241    /// <p>The specified resource tags are invalid.</p>
3242    InvalidTags(String),
3243    /// <p>The specified authentication type is in an invalid format.</p>
3244    InvalidWebhookAuthenticationParameters(String),
3245    /// <p>The specified event filter rule is in an invalid format.</p>
3246    InvalidWebhookFilterPattern(String),
3247    /// <p>The number of pipelines associated with the AWS account has exceeded the limit allowed for the account.</p>
3248    LimitExceeded(String),
3249    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
3250    PipelineNotFound(String),
3251    /// <p>The tags limit for a resource has been exceeded.</p>
3252    TooManyTags(String),
3253}
3254
3255impl PutWebhookError {
3256    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutWebhookError> {
3257        if let Some(err) = proto::json::Error::parse(&res) {
3258            match err.typ.as_str() {
3259                "ConcurrentModificationException" => {
3260                    return RusotoError::Service(PutWebhookError::ConcurrentModification(err.msg))
3261                }
3262                "InvalidTagsException" => {
3263                    return RusotoError::Service(PutWebhookError::InvalidTags(err.msg))
3264                }
3265                "InvalidWebhookAuthenticationParametersException" => {
3266                    return RusotoError::Service(
3267                        PutWebhookError::InvalidWebhookAuthenticationParameters(err.msg),
3268                    )
3269                }
3270                "InvalidWebhookFilterPatternException" => {
3271                    return RusotoError::Service(PutWebhookError::InvalidWebhookFilterPattern(
3272                        err.msg,
3273                    ))
3274                }
3275                "LimitExceededException" => {
3276                    return RusotoError::Service(PutWebhookError::LimitExceeded(err.msg))
3277                }
3278                "PipelineNotFoundException" => {
3279                    return RusotoError::Service(PutWebhookError::PipelineNotFound(err.msg))
3280                }
3281                "TooManyTagsException" => {
3282                    return RusotoError::Service(PutWebhookError::TooManyTags(err.msg))
3283                }
3284                "ValidationException" => return RusotoError::Validation(err.msg),
3285                _ => {}
3286            }
3287        }
3288        RusotoError::Unknown(res)
3289    }
3290}
3291impl fmt::Display for PutWebhookError {
3292    #[allow(unused_variables)]
3293    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3294        match *self {
3295            PutWebhookError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
3296            PutWebhookError::InvalidTags(ref cause) => write!(f, "{}", cause),
3297            PutWebhookError::InvalidWebhookAuthenticationParameters(ref cause) => {
3298                write!(f, "{}", cause)
3299            }
3300            PutWebhookError::InvalidWebhookFilterPattern(ref cause) => write!(f, "{}", cause),
3301            PutWebhookError::LimitExceeded(ref cause) => write!(f, "{}", cause),
3302            PutWebhookError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
3303            PutWebhookError::TooManyTags(ref cause) => write!(f, "{}", cause),
3304        }
3305    }
3306}
3307impl Error for PutWebhookError {}
3308/// Errors returned by RegisterWebhookWithThirdParty
3309#[derive(Debug, PartialEq)]
3310pub enum RegisterWebhookWithThirdPartyError {
3311    /// <p>The specified webhook was entered in an invalid format or cannot be found.</p>
3312    WebhookNotFound(String),
3313}
3314
3315impl RegisterWebhookWithThirdPartyError {
3316    pub fn from_response(
3317        res: BufferedHttpResponse,
3318    ) -> RusotoError<RegisterWebhookWithThirdPartyError> {
3319        if let Some(err) = proto::json::Error::parse(&res) {
3320            match err.typ.as_str() {
3321                "WebhookNotFoundException" => {
3322                    return RusotoError::Service(
3323                        RegisterWebhookWithThirdPartyError::WebhookNotFound(err.msg),
3324                    )
3325                }
3326                "ValidationException" => return RusotoError::Validation(err.msg),
3327                _ => {}
3328            }
3329        }
3330        RusotoError::Unknown(res)
3331    }
3332}
3333impl fmt::Display for RegisterWebhookWithThirdPartyError {
3334    #[allow(unused_variables)]
3335    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3336        match *self {
3337            RegisterWebhookWithThirdPartyError::WebhookNotFound(ref cause) => {
3338                write!(f, "{}", cause)
3339            }
3340        }
3341    }
3342}
3343impl Error for RegisterWebhookWithThirdPartyError {}
3344/// Errors returned by RetryStageExecution
3345#[derive(Debug, PartialEq)]
3346pub enum RetryStageExecutionError {
3347    /// <p>The stage has failed in a later run of the pipeline and the pipelineExecutionId associated with the request is out of date.</p>
3348    NotLatestPipelineExecution(String),
3349    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
3350    PipelineNotFound(String),
3351    /// <p>The stage was specified in an invalid format or cannot be found.</p>
3352    StageNotFound(String),
3353    /// <p>Unable to retry. The pipeline structure or stage state might have changed while actions awaited retry, or the stage contains no failed actions.</p>
3354    StageNotRetryable(String),
3355}
3356
3357impl RetryStageExecutionError {
3358    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RetryStageExecutionError> {
3359        if let Some(err) = proto::json::Error::parse(&res) {
3360            match err.typ.as_str() {
3361                "NotLatestPipelineExecutionException" => {
3362                    return RusotoError::Service(
3363                        RetryStageExecutionError::NotLatestPipelineExecution(err.msg),
3364                    )
3365                }
3366                "PipelineNotFoundException" => {
3367                    return RusotoError::Service(RetryStageExecutionError::PipelineNotFound(
3368                        err.msg,
3369                    ))
3370                }
3371                "StageNotFoundException" => {
3372                    return RusotoError::Service(RetryStageExecutionError::StageNotFound(err.msg))
3373                }
3374                "StageNotRetryableException" => {
3375                    return RusotoError::Service(RetryStageExecutionError::StageNotRetryable(
3376                        err.msg,
3377                    ))
3378                }
3379                "ValidationException" => return RusotoError::Validation(err.msg),
3380                _ => {}
3381            }
3382        }
3383        RusotoError::Unknown(res)
3384    }
3385}
3386impl fmt::Display for RetryStageExecutionError {
3387    #[allow(unused_variables)]
3388    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3389        match *self {
3390            RetryStageExecutionError::NotLatestPipelineExecution(ref cause) => {
3391                write!(f, "{}", cause)
3392            }
3393            RetryStageExecutionError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
3394            RetryStageExecutionError::StageNotFound(ref cause) => write!(f, "{}", cause),
3395            RetryStageExecutionError::StageNotRetryable(ref cause) => write!(f, "{}", cause),
3396        }
3397    }
3398}
3399impl Error for RetryStageExecutionError {}
3400/// Errors returned by StartPipelineExecution
3401#[derive(Debug, PartialEq)]
3402pub enum StartPipelineExecutionError {
3403    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
3404    PipelineNotFound(String),
3405}
3406
3407impl StartPipelineExecutionError {
3408    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartPipelineExecutionError> {
3409        if let Some(err) = proto::json::Error::parse(&res) {
3410            match err.typ.as_str() {
3411                "PipelineNotFoundException" => {
3412                    return RusotoError::Service(StartPipelineExecutionError::PipelineNotFound(
3413                        err.msg,
3414                    ))
3415                }
3416                "ValidationException" => return RusotoError::Validation(err.msg),
3417                _ => {}
3418            }
3419        }
3420        RusotoError::Unknown(res)
3421    }
3422}
3423impl fmt::Display for StartPipelineExecutionError {
3424    #[allow(unused_variables)]
3425    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3426        match *self {
3427            StartPipelineExecutionError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
3428        }
3429    }
3430}
3431impl Error for StartPipelineExecutionError {}
3432/// Errors returned by StopPipelineExecution
3433#[derive(Debug, PartialEq)]
3434pub enum StopPipelineExecutionError {
3435    /// <p>The pipeline execution is already in a <code>Stopping</code> state. If you already chose to stop and wait, you cannot make that request again. You can choose to stop and abandon now, but be aware that this option can lead to failed tasks or out of sequence tasks. If you already chose to stop and abandon, you cannot make that request again.</p>
3436    DuplicatedStopRequest(String),
3437    /// <p>Unable to stop the pipeline execution. The execution might already be in a <code>Stopped</code> state, or it might no longer be in progress.</p>
3438    PipelineExecutionNotStoppable(String),
3439    /// <p>The pipeline was specified in an invalid format or cannot be found.</p>
3440    PipelineNotFound(String),
3441}
3442
3443impl StopPipelineExecutionError {
3444    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopPipelineExecutionError> {
3445        if let Some(err) = proto::json::Error::parse(&res) {
3446            match err.typ.as_str() {
3447                "DuplicatedStopRequestException" => {
3448                    return RusotoError::Service(StopPipelineExecutionError::DuplicatedStopRequest(
3449                        err.msg,
3450                    ))
3451                }
3452                "PipelineExecutionNotStoppableException" => {
3453                    return RusotoError::Service(
3454                        StopPipelineExecutionError::PipelineExecutionNotStoppable(err.msg),
3455                    )
3456                }
3457                "PipelineNotFoundException" => {
3458                    return RusotoError::Service(StopPipelineExecutionError::PipelineNotFound(
3459                        err.msg,
3460                    ))
3461                }
3462                "ValidationException" => return RusotoError::Validation(err.msg),
3463                _ => {}
3464            }
3465        }
3466        RusotoError::Unknown(res)
3467    }
3468}
3469impl fmt::Display for StopPipelineExecutionError {
3470    #[allow(unused_variables)]
3471    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3472        match *self {
3473            StopPipelineExecutionError::DuplicatedStopRequest(ref cause) => write!(f, "{}", cause),
3474            StopPipelineExecutionError::PipelineExecutionNotStoppable(ref cause) => {
3475                write!(f, "{}", cause)
3476            }
3477            StopPipelineExecutionError::PipelineNotFound(ref cause) => write!(f, "{}", cause),
3478        }
3479    }
3480}
3481impl Error for StopPipelineExecutionError {}
3482/// Errors returned by TagResource
3483#[derive(Debug, PartialEq)]
3484pub enum TagResourceError {
3485    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
3486    ConcurrentModification(String),
3487    /// <p>The specified resource ARN is invalid.</p>
3488    InvalidArn(String),
3489    /// <p>The specified resource tags are invalid.</p>
3490    InvalidTags(String),
3491    /// <p>The resource was specified in an invalid format.</p>
3492    ResourceNotFound(String),
3493    /// <p>The tags limit for a resource has been exceeded.</p>
3494    TooManyTags(String),
3495}
3496
3497impl TagResourceError {
3498    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
3499        if let Some(err) = proto::json::Error::parse(&res) {
3500            match err.typ.as_str() {
3501                "ConcurrentModificationException" => {
3502                    return RusotoError::Service(TagResourceError::ConcurrentModification(err.msg))
3503                }
3504                "InvalidArnException" => {
3505                    return RusotoError::Service(TagResourceError::InvalidArn(err.msg))
3506                }
3507                "InvalidTagsException" => {
3508                    return RusotoError::Service(TagResourceError::InvalidTags(err.msg))
3509                }
3510                "ResourceNotFoundException" => {
3511                    return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
3512                }
3513                "TooManyTagsException" => {
3514                    return RusotoError::Service(TagResourceError::TooManyTags(err.msg))
3515                }
3516                "ValidationException" => return RusotoError::Validation(err.msg),
3517                _ => {}
3518            }
3519        }
3520        RusotoError::Unknown(res)
3521    }
3522}
3523impl fmt::Display for TagResourceError {
3524    #[allow(unused_variables)]
3525    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3526        match *self {
3527            TagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
3528            TagResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
3529            TagResourceError::InvalidTags(ref cause) => write!(f, "{}", cause),
3530            TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3531            TagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
3532        }
3533    }
3534}
3535impl Error for TagResourceError {}
3536/// Errors returned by UntagResource
3537#[derive(Debug, PartialEq)]
3538pub enum UntagResourceError {
3539    /// <p>Unable to modify the tag due to a simultaneous update request.</p>
3540    ConcurrentModification(String),
3541    /// <p>The specified resource ARN is invalid.</p>
3542    InvalidArn(String),
3543    /// <p>The specified resource tags are invalid.</p>
3544    InvalidTags(String),
3545    /// <p>The resource was specified in an invalid format.</p>
3546    ResourceNotFound(String),
3547}
3548
3549impl UntagResourceError {
3550    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
3551        if let Some(err) = proto::json::Error::parse(&res) {
3552            match err.typ.as_str() {
3553                "ConcurrentModificationException" => {
3554                    return RusotoError::Service(UntagResourceError::ConcurrentModification(
3555                        err.msg,
3556                    ))
3557                }
3558                "InvalidArnException" => {
3559                    return RusotoError::Service(UntagResourceError::InvalidArn(err.msg))
3560                }
3561                "InvalidTagsException" => {
3562                    return RusotoError::Service(UntagResourceError::InvalidTags(err.msg))
3563                }
3564                "ResourceNotFoundException" => {
3565                    return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
3566                }
3567                "ValidationException" => return RusotoError::Validation(err.msg),
3568                _ => {}
3569            }
3570        }
3571        RusotoError::Unknown(res)
3572    }
3573}
3574impl fmt::Display for UntagResourceError {
3575    #[allow(unused_variables)]
3576    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3577        match *self {
3578            UntagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
3579            UntagResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
3580            UntagResourceError::InvalidTags(ref cause) => write!(f, "{}", cause),
3581            UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
3582        }
3583    }
3584}
3585impl Error for UntagResourceError {}
3586/// Errors returned by UpdatePipeline
3587#[derive(Debug, PartialEq)]
3588pub enum UpdatePipelineError {
3589    /// <p>The action declaration was specified in an invalid format.</p>
3590    InvalidActionDeclaration(String),
3591    /// <p>Reserved for future use.</p>
3592    InvalidBlockerDeclaration(String),
3593    /// <p>The stage declaration was specified in an invalid format.</p>
3594    InvalidStageDeclaration(String),
3595    /// <p>The structure was specified in an invalid format.</p>
3596    InvalidStructure(String),
3597    /// <p>The number of pipelines associated with the AWS account has exceeded the limit allowed for the account.</p>
3598    LimitExceeded(String),
3599}
3600
3601impl UpdatePipelineError {
3602    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePipelineError> {
3603        if let Some(err) = proto::json::Error::parse(&res) {
3604            match err.typ.as_str() {
3605                "InvalidActionDeclarationException" => {
3606                    return RusotoError::Service(UpdatePipelineError::InvalidActionDeclaration(
3607                        err.msg,
3608                    ))
3609                }
3610                "InvalidBlockerDeclarationException" => {
3611                    return RusotoError::Service(UpdatePipelineError::InvalidBlockerDeclaration(
3612                        err.msg,
3613                    ))
3614                }
3615                "InvalidStageDeclarationException" => {
3616                    return RusotoError::Service(UpdatePipelineError::InvalidStageDeclaration(
3617                        err.msg,
3618                    ))
3619                }
3620                "InvalidStructureException" => {
3621                    return RusotoError::Service(UpdatePipelineError::InvalidStructure(err.msg))
3622                }
3623                "LimitExceededException" => {
3624                    return RusotoError::Service(UpdatePipelineError::LimitExceeded(err.msg))
3625                }
3626                "ValidationException" => return RusotoError::Validation(err.msg),
3627                _ => {}
3628            }
3629        }
3630        RusotoError::Unknown(res)
3631    }
3632}
3633impl fmt::Display for UpdatePipelineError {
3634    #[allow(unused_variables)]
3635    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3636        match *self {
3637            UpdatePipelineError::InvalidActionDeclaration(ref cause) => write!(f, "{}", cause),
3638            UpdatePipelineError::InvalidBlockerDeclaration(ref cause) => write!(f, "{}", cause),
3639            UpdatePipelineError::InvalidStageDeclaration(ref cause) => write!(f, "{}", cause),
3640            UpdatePipelineError::InvalidStructure(ref cause) => write!(f, "{}", cause),
3641            UpdatePipelineError::LimitExceeded(ref cause) => write!(f, "{}", cause),
3642        }
3643    }
3644}
3645impl Error for UpdatePipelineError {}
3646/// Trait representing the capabilities of the CodePipeline API. CodePipeline clients implement this trait.
3647#[async_trait]
3648pub trait CodePipeline {
3649    /// <p>Returns information about a specified job and whether that job has been received by the job worker. Used for custom actions only.</p>
3650    async fn acknowledge_job(
3651        &self,
3652        input: AcknowledgeJobInput,
3653    ) -> Result<AcknowledgeJobOutput, RusotoError<AcknowledgeJobError>>;
3654
3655    /// <p>Confirms a job worker has received the specified job. Used for partner actions only.</p>
3656    async fn acknowledge_third_party_job(
3657        &self,
3658        input: AcknowledgeThirdPartyJobInput,
3659    ) -> Result<AcknowledgeThirdPartyJobOutput, RusotoError<AcknowledgeThirdPartyJobError>>;
3660
3661    /// <p>Creates a new custom action that can be used in all pipelines associated with the AWS account. Only used for custom actions.</p>
3662    async fn create_custom_action_type(
3663        &self,
3664        input: CreateCustomActionTypeInput,
3665    ) -> Result<CreateCustomActionTypeOutput, RusotoError<CreateCustomActionTypeError>>;
3666
3667    /// <p><p>Creates a pipeline.</p> <note> <p>In the pipeline structure, you must include either <code>artifactStore</code> or <code>artifactStores</code> in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use <code>artifactStores</code>.</p> </note></p>
3668    async fn create_pipeline(
3669        &self,
3670        input: CreatePipelineInput,
3671    ) -> Result<CreatePipelineOutput, RusotoError<CreatePipelineError>>;
3672
3673    /// <p><p>Marks a custom action as deleted. <code>PollForJobs</code> for the custom action fails after the action is marked for deletion. Used for custom actions only.</p> <important> <p>To re-create a custom action after it has been deleted you must use a string in the version field that has never been used before. This string can be an incremented version number, for example. To restore a deleted custom action, use a JSON file that is identical to the deleted action, including the original string in the version field.</p> </important></p>
3674    async fn delete_custom_action_type(
3675        &self,
3676        input: DeleteCustomActionTypeInput,
3677    ) -> Result<(), RusotoError<DeleteCustomActionTypeError>>;
3678
3679    /// <p>Deletes the specified pipeline.</p>
3680    async fn delete_pipeline(
3681        &self,
3682        input: DeletePipelineInput,
3683    ) -> Result<(), RusotoError<DeletePipelineError>>;
3684
3685    /// <p>Deletes a previously created webhook by name. Deleting the webhook stops AWS CodePipeline from starting a pipeline every time an external event occurs. The API returns successfully when trying to delete a webhook that is already deleted. If a deleted webhook is re-created by calling PutWebhook with the same name, it will have a different URL.</p>
3686    async fn delete_webhook(
3687        &self,
3688        input: DeleteWebhookInput,
3689    ) -> Result<DeleteWebhookOutput, RusotoError<DeleteWebhookError>>;
3690
3691    /// <p>Removes the connection between the webhook that was created by CodePipeline and the external tool with events to be detected. Currently supported only for webhooks that target an action type of GitHub.</p>
3692    async fn deregister_webhook_with_third_party(
3693        &self,
3694        input: DeregisterWebhookWithThirdPartyInput,
3695    ) -> Result<
3696        DeregisterWebhookWithThirdPartyOutput,
3697        RusotoError<DeregisterWebhookWithThirdPartyError>,
3698    >;
3699
3700    /// <p>Prevents artifacts in a pipeline from transitioning to the next stage in the pipeline.</p>
3701    async fn disable_stage_transition(
3702        &self,
3703        input: DisableStageTransitionInput,
3704    ) -> Result<(), RusotoError<DisableStageTransitionError>>;
3705
3706    /// <p>Enables artifacts in a pipeline to transition to a stage in a pipeline.</p>
3707    async fn enable_stage_transition(
3708        &self,
3709        input: EnableStageTransitionInput,
3710    ) -> Result<(), RusotoError<EnableStageTransitionError>>;
3711
3712    /// <p><p>Returns information about a job. Used for custom actions only.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts. This API also returns any secret values defined for the action.</p> </important></p>
3713    async fn get_job_details(
3714        &self,
3715        input: GetJobDetailsInput,
3716    ) -> Result<GetJobDetailsOutput, RusotoError<GetJobDetailsError>>;
3717
3718    /// <p>Returns the metadata, structure, stages, and actions of a pipeline. Can be used to return the entire structure of a pipeline in JSON format, which can then be modified and used to update the pipeline structure with <a>UpdatePipeline</a>.</p>
3719    async fn get_pipeline(
3720        &self,
3721        input: GetPipelineInput,
3722    ) -> Result<GetPipelineOutput, RusotoError<GetPipelineError>>;
3723
3724    /// <p>Returns information about an execution of a pipeline, including details about artifacts, the pipeline execution ID, and the name, version, and status of the pipeline.</p>
3725    async fn get_pipeline_execution(
3726        &self,
3727        input: GetPipelineExecutionInput,
3728    ) -> Result<GetPipelineExecutionOutput, RusotoError<GetPipelineExecutionError>>;
3729
3730    /// <p><p>Returns information about the state of a pipeline, including the stages and actions.</p> <note> <p>Values returned in the <code>revisionId</code> and <code>revisionUrl</code> fields indicate the source revision information, such as the commit ID, for the current state.</p> </note></p>
3731    async fn get_pipeline_state(
3732        &self,
3733        input: GetPipelineStateInput,
3734    ) -> Result<GetPipelineStateOutput, RusotoError<GetPipelineStateError>>;
3735
3736    /// <p><p>Requests the details of a job for a third party action. Used for partner actions only.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts. This API also returns any secret values defined for the action.</p> </important></p>
3737    async fn get_third_party_job_details(
3738        &self,
3739        input: GetThirdPartyJobDetailsInput,
3740    ) -> Result<GetThirdPartyJobDetailsOutput, RusotoError<GetThirdPartyJobDetailsError>>;
3741
3742    /// <p>Lists the action executions that have occurred in a pipeline.</p>
3743    async fn list_action_executions(
3744        &self,
3745        input: ListActionExecutionsInput,
3746    ) -> Result<ListActionExecutionsOutput, RusotoError<ListActionExecutionsError>>;
3747
3748    /// <p>Gets a summary of all AWS CodePipeline action types associated with your account.</p>
3749    async fn list_action_types(
3750        &self,
3751        input: ListActionTypesInput,
3752    ) -> Result<ListActionTypesOutput, RusotoError<ListActionTypesError>>;
3753
3754    /// <p>Gets a summary of the most recent executions for a pipeline.</p>
3755    async fn list_pipeline_executions(
3756        &self,
3757        input: ListPipelineExecutionsInput,
3758    ) -> Result<ListPipelineExecutionsOutput, RusotoError<ListPipelineExecutionsError>>;
3759
3760    /// <p>Gets a summary of all of the pipelines associated with your account.</p>
3761    async fn list_pipelines(
3762        &self,
3763        input: ListPipelinesInput,
3764    ) -> Result<ListPipelinesOutput, RusotoError<ListPipelinesError>>;
3765
3766    /// <p>Gets the set of key-value pairs (metadata) that are used to manage the resource.</p>
3767    async fn list_tags_for_resource(
3768        &self,
3769        input: ListTagsForResourceInput,
3770    ) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>>;
3771
3772    /// <p>Gets a listing of all the webhooks in this AWS Region for this account. The output lists all webhooks and includes the webhook URL and ARN and the configuration for each webhook.</p>
3773    async fn list_webhooks(
3774        &self,
3775        input: ListWebhooksInput,
3776    ) -> Result<ListWebhooksOutput, RusotoError<ListWebhooksError>>;
3777
3778    /// <p><p>Returns information about any jobs for AWS CodePipeline to act on. <code>PollForJobs</code> is valid only for action types with &quot;Custom&quot; in the owner field. If the action type contains &quot;AWS&quot; or &quot;ThirdParty&quot; in the owner field, the <code>PollForJobs</code> action returns an error.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts. This API also returns any secret values defined for the action.</p> </important></p>
3779    async fn poll_for_jobs(
3780        &self,
3781        input: PollForJobsInput,
3782    ) -> Result<PollForJobsOutput, RusotoError<PollForJobsError>>;
3783
3784    /// <p><p>Determines whether there are any third party jobs for a job worker to act on. Used for partner actions only.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts.</p> </important></p>
3785    async fn poll_for_third_party_jobs(
3786        &self,
3787        input: PollForThirdPartyJobsInput,
3788    ) -> Result<PollForThirdPartyJobsOutput, RusotoError<PollForThirdPartyJobsError>>;
3789
3790    /// <p>Provides information to AWS CodePipeline about new revisions to a source.</p>
3791    async fn put_action_revision(
3792        &self,
3793        input: PutActionRevisionInput,
3794    ) -> Result<PutActionRevisionOutput, RusotoError<PutActionRevisionError>>;
3795
3796    /// <p>Provides the response to a manual approval request to AWS CodePipeline. Valid responses include Approved and Rejected.</p>
3797    async fn put_approval_result(
3798        &self,
3799        input: PutApprovalResultInput,
3800    ) -> Result<PutApprovalResultOutput, RusotoError<PutApprovalResultError>>;
3801
3802    /// <p>Represents the failure of a job as returned to the pipeline by a job worker. Used for custom actions only.</p>
3803    async fn put_job_failure_result(
3804        &self,
3805        input: PutJobFailureResultInput,
3806    ) -> Result<(), RusotoError<PutJobFailureResultError>>;
3807
3808    /// <p>Represents the success of a job as returned to the pipeline by a job worker. Used for custom actions only.</p>
3809    async fn put_job_success_result(
3810        &self,
3811        input: PutJobSuccessResultInput,
3812    ) -> Result<(), RusotoError<PutJobSuccessResultError>>;
3813
3814    /// <p>Represents the failure of a third party job as returned to the pipeline by a job worker. Used for partner actions only.</p>
3815    async fn put_third_party_job_failure_result(
3816        &self,
3817        input: PutThirdPartyJobFailureResultInput,
3818    ) -> Result<(), RusotoError<PutThirdPartyJobFailureResultError>>;
3819
3820    /// <p>Represents the success of a third party job as returned to the pipeline by a job worker. Used for partner actions only.</p>
3821    async fn put_third_party_job_success_result(
3822        &self,
3823        input: PutThirdPartyJobSuccessResultInput,
3824    ) -> Result<(), RusotoError<PutThirdPartyJobSuccessResultError>>;
3825
3826    /// <p>Defines a webhook and returns a unique webhook URL generated by CodePipeline. This URL can be supplied to third party source hosting providers to call every time there's a code change. When CodePipeline receives a POST request on this URL, the pipeline defined in the webhook is started as long as the POST request satisfied the authentication and filtering requirements supplied when defining the webhook. RegisterWebhookWithThirdParty and DeregisterWebhookWithThirdParty APIs can be used to automatically configure supported third parties to call the generated webhook URL.</p>
3827    async fn put_webhook(
3828        &self,
3829        input: PutWebhookInput,
3830    ) -> Result<PutWebhookOutput, RusotoError<PutWebhookError>>;
3831
3832    /// <p>Configures a connection between the webhook that was created and the external tool with events to be detected.</p>
3833    async fn register_webhook_with_third_party(
3834        &self,
3835        input: RegisterWebhookWithThirdPartyInput,
3836    ) -> Result<RegisterWebhookWithThirdPartyOutput, RusotoError<RegisterWebhookWithThirdPartyError>>;
3837
3838    /// <p>Resumes the pipeline execution by retrying the last failed actions in a stage. You can retry a stage immediately if any of the actions in the stage fail. When you retry, all actions that are still in progress continue working, and failed actions are triggered again.</p>
3839    async fn retry_stage_execution(
3840        &self,
3841        input: RetryStageExecutionInput,
3842    ) -> Result<RetryStageExecutionOutput, RusotoError<RetryStageExecutionError>>;
3843
3844    /// <p>Starts the specified pipeline. Specifically, it begins processing the latest commit to the source location specified as part of the pipeline.</p>
3845    async fn start_pipeline_execution(
3846        &self,
3847        input: StartPipelineExecutionInput,
3848    ) -> Result<StartPipelineExecutionOutput, RusotoError<StartPipelineExecutionError>>;
3849
3850    /// <p>Stops the specified pipeline execution. You choose to either stop the pipeline execution by completing in-progress actions without starting subsequent actions, or by abandoning in-progress actions. While completing or abandoning in-progress actions, the pipeline execution is in a <code>Stopping</code> state. After all in-progress actions are completed or abandoned, the pipeline execution is in a <code>Stopped</code> state.</p>
3851    async fn stop_pipeline_execution(
3852        &self,
3853        input: StopPipelineExecutionInput,
3854    ) -> Result<StopPipelineExecutionOutput, RusotoError<StopPipelineExecutionError>>;
3855
3856    /// <p>Adds to or modifies the tags of the given resource. Tags are metadata that can be used to manage a resource. </p>
3857    async fn tag_resource(
3858        &self,
3859        input: TagResourceInput,
3860    ) -> Result<TagResourceOutput, RusotoError<TagResourceError>>;
3861
3862    /// <p>Removes tags from an AWS resource.</p>
3863    async fn untag_resource(
3864        &self,
3865        input: UntagResourceInput,
3866    ) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>>;
3867
3868    /// <p>Updates a specified pipeline with edits or changes to its structure. Use a JSON file with the pipeline structure and <code>UpdatePipeline</code> to provide the full structure of the pipeline. Updating the pipeline increases the version number of the pipeline by 1.</p>
3869    async fn update_pipeline(
3870        &self,
3871        input: UpdatePipelineInput,
3872    ) -> Result<UpdatePipelineOutput, RusotoError<UpdatePipelineError>>;
3873}
3874/// A client for the CodePipeline API.
3875#[derive(Clone)]
3876pub struct CodePipelineClient {
3877    client: Client,
3878    region: region::Region,
3879}
3880
3881impl CodePipelineClient {
3882    /// Creates a client backed by the default tokio event loop.
3883    ///
3884    /// The client will use the default credentials provider and tls client.
3885    pub fn new(region: region::Region) -> CodePipelineClient {
3886        CodePipelineClient {
3887            client: Client::shared(),
3888            region,
3889        }
3890    }
3891
3892    pub fn new_with<P, D>(
3893        request_dispatcher: D,
3894        credentials_provider: P,
3895        region: region::Region,
3896    ) -> CodePipelineClient
3897    where
3898        P: ProvideAwsCredentials + Send + Sync + 'static,
3899        D: DispatchSignedRequest + Send + Sync + 'static,
3900    {
3901        CodePipelineClient {
3902            client: Client::new_with(credentials_provider, request_dispatcher),
3903            region,
3904        }
3905    }
3906
3907    pub fn new_with_client(client: Client, region: region::Region) -> CodePipelineClient {
3908        CodePipelineClient { client, region }
3909    }
3910}
3911
3912#[async_trait]
3913impl CodePipeline for CodePipelineClient {
3914    /// <p>Returns information about a specified job and whether that job has been received by the job worker. Used for custom actions only.</p>
3915    async fn acknowledge_job(
3916        &self,
3917        input: AcknowledgeJobInput,
3918    ) -> Result<AcknowledgeJobOutput, RusotoError<AcknowledgeJobError>> {
3919        let mut request = self.new_signed_request("POST", "/");
3920        request.add_header("x-amz-target", "CodePipeline_20150709.AcknowledgeJob");
3921        let encoded = serde_json::to_string(&input).unwrap();
3922        request.set_payload(Some(encoded));
3923
3924        let response = self
3925            .sign_and_dispatch(request, AcknowledgeJobError::from_response)
3926            .await?;
3927        let mut response = response;
3928        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
3929        proto::json::ResponsePayload::new(&response).deserialize::<AcknowledgeJobOutput, _>()
3930    }
3931
3932    /// <p>Confirms a job worker has received the specified job. Used for partner actions only.</p>
3933    async fn acknowledge_third_party_job(
3934        &self,
3935        input: AcknowledgeThirdPartyJobInput,
3936    ) -> Result<AcknowledgeThirdPartyJobOutput, RusotoError<AcknowledgeThirdPartyJobError>> {
3937        let mut request = self.new_signed_request("POST", "/");
3938        request.add_header(
3939            "x-amz-target",
3940            "CodePipeline_20150709.AcknowledgeThirdPartyJob",
3941        );
3942        let encoded = serde_json::to_string(&input).unwrap();
3943        request.set_payload(Some(encoded));
3944
3945        let response = self
3946            .sign_and_dispatch(request, AcknowledgeThirdPartyJobError::from_response)
3947            .await?;
3948        let mut response = response;
3949        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
3950        proto::json::ResponsePayload::new(&response)
3951            .deserialize::<AcknowledgeThirdPartyJobOutput, _>()
3952    }
3953
3954    /// <p>Creates a new custom action that can be used in all pipelines associated with the AWS account. Only used for custom actions.</p>
3955    async fn create_custom_action_type(
3956        &self,
3957        input: CreateCustomActionTypeInput,
3958    ) -> Result<CreateCustomActionTypeOutput, RusotoError<CreateCustomActionTypeError>> {
3959        let mut request = self.new_signed_request("POST", "/");
3960        request.add_header(
3961            "x-amz-target",
3962            "CodePipeline_20150709.CreateCustomActionType",
3963        );
3964        let encoded = serde_json::to_string(&input).unwrap();
3965        request.set_payload(Some(encoded));
3966
3967        let response = self
3968            .sign_and_dispatch(request, CreateCustomActionTypeError::from_response)
3969            .await?;
3970        let mut response = response;
3971        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
3972        proto::json::ResponsePayload::new(&response)
3973            .deserialize::<CreateCustomActionTypeOutput, _>()
3974    }
3975
3976    /// <p><p>Creates a pipeline.</p> <note> <p>In the pipeline structure, you must include either <code>artifactStore</code> or <code>artifactStores</code> in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use <code>artifactStores</code>.</p> </note></p>
3977    async fn create_pipeline(
3978        &self,
3979        input: CreatePipelineInput,
3980    ) -> Result<CreatePipelineOutput, RusotoError<CreatePipelineError>> {
3981        let mut request = self.new_signed_request("POST", "/");
3982        request.add_header("x-amz-target", "CodePipeline_20150709.CreatePipeline");
3983        let encoded = serde_json::to_string(&input).unwrap();
3984        request.set_payload(Some(encoded));
3985
3986        let response = self
3987            .sign_and_dispatch(request, CreatePipelineError::from_response)
3988            .await?;
3989        let mut response = response;
3990        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
3991        proto::json::ResponsePayload::new(&response).deserialize::<CreatePipelineOutput, _>()
3992    }
3993
3994    /// <p><p>Marks a custom action as deleted. <code>PollForJobs</code> for the custom action fails after the action is marked for deletion. Used for custom actions only.</p> <important> <p>To re-create a custom action after it has been deleted you must use a string in the version field that has never been used before. This string can be an incremented version number, for example. To restore a deleted custom action, use a JSON file that is identical to the deleted action, including the original string in the version field.</p> </important></p>
3995    async fn delete_custom_action_type(
3996        &self,
3997        input: DeleteCustomActionTypeInput,
3998    ) -> Result<(), RusotoError<DeleteCustomActionTypeError>> {
3999        let mut request = self.new_signed_request("POST", "/");
4000        request.add_header(
4001            "x-amz-target",
4002            "CodePipeline_20150709.DeleteCustomActionType",
4003        );
4004        let encoded = serde_json::to_string(&input).unwrap();
4005        request.set_payload(Some(encoded));
4006
4007        let response = self
4008            .sign_and_dispatch(request, DeleteCustomActionTypeError::from_response)
4009            .await?;
4010        std::mem::drop(response);
4011        Ok(())
4012    }
4013
4014    /// <p>Deletes the specified pipeline.</p>
4015    async fn delete_pipeline(
4016        &self,
4017        input: DeletePipelineInput,
4018    ) -> Result<(), RusotoError<DeletePipelineError>> {
4019        let mut request = self.new_signed_request("POST", "/");
4020        request.add_header("x-amz-target", "CodePipeline_20150709.DeletePipeline");
4021        let encoded = serde_json::to_string(&input).unwrap();
4022        request.set_payload(Some(encoded));
4023
4024        let response = self
4025            .sign_and_dispatch(request, DeletePipelineError::from_response)
4026            .await?;
4027        std::mem::drop(response);
4028        Ok(())
4029    }
4030
4031    /// <p>Deletes a previously created webhook by name. Deleting the webhook stops AWS CodePipeline from starting a pipeline every time an external event occurs. The API returns successfully when trying to delete a webhook that is already deleted. If a deleted webhook is re-created by calling PutWebhook with the same name, it will have a different URL.</p>
4032    async fn delete_webhook(
4033        &self,
4034        input: DeleteWebhookInput,
4035    ) -> Result<DeleteWebhookOutput, RusotoError<DeleteWebhookError>> {
4036        let mut request = self.new_signed_request("POST", "/");
4037        request.add_header("x-amz-target", "CodePipeline_20150709.DeleteWebhook");
4038        let encoded = serde_json::to_string(&input).unwrap();
4039        request.set_payload(Some(encoded));
4040
4041        let response = self
4042            .sign_and_dispatch(request, DeleteWebhookError::from_response)
4043            .await?;
4044        let mut response = response;
4045        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4046        proto::json::ResponsePayload::new(&response).deserialize::<DeleteWebhookOutput, _>()
4047    }
4048
4049    /// <p>Removes the connection between the webhook that was created by CodePipeline and the external tool with events to be detected. Currently supported only for webhooks that target an action type of GitHub.</p>
4050    async fn deregister_webhook_with_third_party(
4051        &self,
4052        input: DeregisterWebhookWithThirdPartyInput,
4053    ) -> Result<
4054        DeregisterWebhookWithThirdPartyOutput,
4055        RusotoError<DeregisterWebhookWithThirdPartyError>,
4056    > {
4057        let mut request = self.new_signed_request("POST", "/");
4058        request.add_header(
4059            "x-amz-target",
4060            "CodePipeline_20150709.DeregisterWebhookWithThirdParty",
4061        );
4062        let encoded = serde_json::to_string(&input).unwrap();
4063        request.set_payload(Some(encoded));
4064
4065        let response = self
4066            .sign_and_dispatch(request, DeregisterWebhookWithThirdPartyError::from_response)
4067            .await?;
4068        let mut response = response;
4069        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4070        proto::json::ResponsePayload::new(&response)
4071            .deserialize::<DeregisterWebhookWithThirdPartyOutput, _>()
4072    }
4073
4074    /// <p>Prevents artifacts in a pipeline from transitioning to the next stage in the pipeline.</p>
4075    async fn disable_stage_transition(
4076        &self,
4077        input: DisableStageTransitionInput,
4078    ) -> Result<(), RusotoError<DisableStageTransitionError>> {
4079        let mut request = self.new_signed_request("POST", "/");
4080        request.add_header(
4081            "x-amz-target",
4082            "CodePipeline_20150709.DisableStageTransition",
4083        );
4084        let encoded = serde_json::to_string(&input).unwrap();
4085        request.set_payload(Some(encoded));
4086
4087        let response = self
4088            .sign_and_dispatch(request, DisableStageTransitionError::from_response)
4089            .await?;
4090        std::mem::drop(response);
4091        Ok(())
4092    }
4093
4094    /// <p>Enables artifacts in a pipeline to transition to a stage in a pipeline.</p>
4095    async fn enable_stage_transition(
4096        &self,
4097        input: EnableStageTransitionInput,
4098    ) -> Result<(), RusotoError<EnableStageTransitionError>> {
4099        let mut request = self.new_signed_request("POST", "/");
4100        request.add_header(
4101            "x-amz-target",
4102            "CodePipeline_20150709.EnableStageTransition",
4103        );
4104        let encoded = serde_json::to_string(&input).unwrap();
4105        request.set_payload(Some(encoded));
4106
4107        let response = self
4108            .sign_and_dispatch(request, EnableStageTransitionError::from_response)
4109            .await?;
4110        std::mem::drop(response);
4111        Ok(())
4112    }
4113
4114    /// <p><p>Returns information about a job. Used for custom actions only.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts. This API also returns any secret values defined for the action.</p> </important></p>
4115    async fn get_job_details(
4116        &self,
4117        input: GetJobDetailsInput,
4118    ) -> Result<GetJobDetailsOutput, RusotoError<GetJobDetailsError>> {
4119        let mut request = self.new_signed_request("POST", "/");
4120        request.add_header("x-amz-target", "CodePipeline_20150709.GetJobDetails");
4121        let encoded = serde_json::to_string(&input).unwrap();
4122        request.set_payload(Some(encoded));
4123
4124        let response = self
4125            .sign_and_dispatch(request, GetJobDetailsError::from_response)
4126            .await?;
4127        let mut response = response;
4128        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4129        proto::json::ResponsePayload::new(&response).deserialize::<GetJobDetailsOutput, _>()
4130    }
4131
4132    /// <p>Returns the metadata, structure, stages, and actions of a pipeline. Can be used to return the entire structure of a pipeline in JSON format, which can then be modified and used to update the pipeline structure with <a>UpdatePipeline</a>.</p>
4133    async fn get_pipeline(
4134        &self,
4135        input: GetPipelineInput,
4136    ) -> Result<GetPipelineOutput, RusotoError<GetPipelineError>> {
4137        let mut request = self.new_signed_request("POST", "/");
4138        request.add_header("x-amz-target", "CodePipeline_20150709.GetPipeline");
4139        let encoded = serde_json::to_string(&input).unwrap();
4140        request.set_payload(Some(encoded));
4141
4142        let response = self
4143            .sign_and_dispatch(request, GetPipelineError::from_response)
4144            .await?;
4145        let mut response = response;
4146        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4147        proto::json::ResponsePayload::new(&response).deserialize::<GetPipelineOutput, _>()
4148    }
4149
4150    /// <p>Returns information about an execution of a pipeline, including details about artifacts, the pipeline execution ID, and the name, version, and status of the pipeline.</p>
4151    async fn get_pipeline_execution(
4152        &self,
4153        input: GetPipelineExecutionInput,
4154    ) -> Result<GetPipelineExecutionOutput, RusotoError<GetPipelineExecutionError>> {
4155        let mut request = self.new_signed_request("POST", "/");
4156        request.add_header("x-amz-target", "CodePipeline_20150709.GetPipelineExecution");
4157        let encoded = serde_json::to_string(&input).unwrap();
4158        request.set_payload(Some(encoded));
4159
4160        let response = self
4161            .sign_and_dispatch(request, GetPipelineExecutionError::from_response)
4162            .await?;
4163        let mut response = response;
4164        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4165        proto::json::ResponsePayload::new(&response).deserialize::<GetPipelineExecutionOutput, _>()
4166    }
4167
4168    /// <p><p>Returns information about the state of a pipeline, including the stages and actions.</p> <note> <p>Values returned in the <code>revisionId</code> and <code>revisionUrl</code> fields indicate the source revision information, such as the commit ID, for the current state.</p> </note></p>
4169    async fn get_pipeline_state(
4170        &self,
4171        input: GetPipelineStateInput,
4172    ) -> Result<GetPipelineStateOutput, RusotoError<GetPipelineStateError>> {
4173        let mut request = self.new_signed_request("POST", "/");
4174        request.add_header("x-amz-target", "CodePipeline_20150709.GetPipelineState");
4175        let encoded = serde_json::to_string(&input).unwrap();
4176        request.set_payload(Some(encoded));
4177
4178        let response = self
4179            .sign_and_dispatch(request, GetPipelineStateError::from_response)
4180            .await?;
4181        let mut response = response;
4182        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4183        proto::json::ResponsePayload::new(&response).deserialize::<GetPipelineStateOutput, _>()
4184    }
4185
4186    /// <p><p>Requests the details of a job for a third party action. Used for partner actions only.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts. This API also returns any secret values defined for the action.</p> </important></p>
4187    async fn get_third_party_job_details(
4188        &self,
4189        input: GetThirdPartyJobDetailsInput,
4190    ) -> Result<GetThirdPartyJobDetailsOutput, RusotoError<GetThirdPartyJobDetailsError>> {
4191        let mut request = self.new_signed_request("POST", "/");
4192        request.add_header(
4193            "x-amz-target",
4194            "CodePipeline_20150709.GetThirdPartyJobDetails",
4195        );
4196        let encoded = serde_json::to_string(&input).unwrap();
4197        request.set_payload(Some(encoded));
4198
4199        let response = self
4200            .sign_and_dispatch(request, GetThirdPartyJobDetailsError::from_response)
4201            .await?;
4202        let mut response = response;
4203        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4204        proto::json::ResponsePayload::new(&response)
4205            .deserialize::<GetThirdPartyJobDetailsOutput, _>()
4206    }
4207
4208    /// <p>Lists the action executions that have occurred in a pipeline.</p>
4209    async fn list_action_executions(
4210        &self,
4211        input: ListActionExecutionsInput,
4212    ) -> Result<ListActionExecutionsOutput, RusotoError<ListActionExecutionsError>> {
4213        let mut request = self.new_signed_request("POST", "/");
4214        request.add_header("x-amz-target", "CodePipeline_20150709.ListActionExecutions");
4215        let encoded = serde_json::to_string(&input).unwrap();
4216        request.set_payload(Some(encoded));
4217
4218        let response = self
4219            .sign_and_dispatch(request, ListActionExecutionsError::from_response)
4220            .await?;
4221        let mut response = response;
4222        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4223        proto::json::ResponsePayload::new(&response).deserialize::<ListActionExecutionsOutput, _>()
4224    }
4225
4226    /// <p>Gets a summary of all AWS CodePipeline action types associated with your account.</p>
4227    async fn list_action_types(
4228        &self,
4229        input: ListActionTypesInput,
4230    ) -> Result<ListActionTypesOutput, RusotoError<ListActionTypesError>> {
4231        let mut request = self.new_signed_request("POST", "/");
4232        request.add_header("x-amz-target", "CodePipeline_20150709.ListActionTypes");
4233        let encoded = serde_json::to_string(&input).unwrap();
4234        request.set_payload(Some(encoded));
4235
4236        let response = self
4237            .sign_and_dispatch(request, ListActionTypesError::from_response)
4238            .await?;
4239        let mut response = response;
4240        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4241        proto::json::ResponsePayload::new(&response).deserialize::<ListActionTypesOutput, _>()
4242    }
4243
4244    /// <p>Gets a summary of the most recent executions for a pipeline.</p>
4245    async fn list_pipeline_executions(
4246        &self,
4247        input: ListPipelineExecutionsInput,
4248    ) -> Result<ListPipelineExecutionsOutput, RusotoError<ListPipelineExecutionsError>> {
4249        let mut request = self.new_signed_request("POST", "/");
4250        request.add_header(
4251            "x-amz-target",
4252            "CodePipeline_20150709.ListPipelineExecutions",
4253        );
4254        let encoded = serde_json::to_string(&input).unwrap();
4255        request.set_payload(Some(encoded));
4256
4257        let response = self
4258            .sign_and_dispatch(request, ListPipelineExecutionsError::from_response)
4259            .await?;
4260        let mut response = response;
4261        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4262        proto::json::ResponsePayload::new(&response)
4263            .deserialize::<ListPipelineExecutionsOutput, _>()
4264    }
4265
4266    /// <p>Gets a summary of all of the pipelines associated with your account.</p>
4267    async fn list_pipelines(
4268        &self,
4269        input: ListPipelinesInput,
4270    ) -> Result<ListPipelinesOutput, RusotoError<ListPipelinesError>> {
4271        let mut request = self.new_signed_request("POST", "/");
4272        request.add_header("x-amz-target", "CodePipeline_20150709.ListPipelines");
4273        let encoded = serde_json::to_string(&input).unwrap();
4274        request.set_payload(Some(encoded));
4275
4276        let response = self
4277            .sign_and_dispatch(request, ListPipelinesError::from_response)
4278            .await?;
4279        let mut response = response;
4280        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4281        proto::json::ResponsePayload::new(&response).deserialize::<ListPipelinesOutput, _>()
4282    }
4283
4284    /// <p>Gets the set of key-value pairs (metadata) that are used to manage the resource.</p>
4285    async fn list_tags_for_resource(
4286        &self,
4287        input: ListTagsForResourceInput,
4288    ) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>> {
4289        let mut request = self.new_signed_request("POST", "/");
4290        request.add_header("x-amz-target", "CodePipeline_20150709.ListTagsForResource");
4291        let encoded = serde_json::to_string(&input).unwrap();
4292        request.set_payload(Some(encoded));
4293
4294        let response = self
4295            .sign_and_dispatch(request, ListTagsForResourceError::from_response)
4296            .await?;
4297        let mut response = response;
4298        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4299        proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceOutput, _>()
4300    }
4301
4302    /// <p>Gets a listing of all the webhooks in this AWS Region for this account. The output lists all webhooks and includes the webhook URL and ARN and the configuration for each webhook.</p>
4303    async fn list_webhooks(
4304        &self,
4305        input: ListWebhooksInput,
4306    ) -> Result<ListWebhooksOutput, RusotoError<ListWebhooksError>> {
4307        let mut request = self.new_signed_request("POST", "/");
4308        request.add_header("x-amz-target", "CodePipeline_20150709.ListWebhooks");
4309        let encoded = serde_json::to_string(&input).unwrap();
4310        request.set_payload(Some(encoded));
4311
4312        let response = self
4313            .sign_and_dispatch(request, ListWebhooksError::from_response)
4314            .await?;
4315        let mut response = response;
4316        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4317        proto::json::ResponsePayload::new(&response).deserialize::<ListWebhooksOutput, _>()
4318    }
4319
4320    /// <p><p>Returns information about any jobs for AWS CodePipeline to act on. <code>PollForJobs</code> is valid only for action types with &quot;Custom&quot; in the owner field. If the action type contains &quot;AWS&quot; or &quot;ThirdParty&quot; in the owner field, the <code>PollForJobs</code> action returns an error.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts. This API also returns any secret values defined for the action.</p> </important></p>
4321    async fn poll_for_jobs(
4322        &self,
4323        input: PollForJobsInput,
4324    ) -> Result<PollForJobsOutput, RusotoError<PollForJobsError>> {
4325        let mut request = self.new_signed_request("POST", "/");
4326        request.add_header("x-amz-target", "CodePipeline_20150709.PollForJobs");
4327        let encoded = serde_json::to_string(&input).unwrap();
4328        request.set_payload(Some(encoded));
4329
4330        let response = self
4331            .sign_and_dispatch(request, PollForJobsError::from_response)
4332            .await?;
4333        let mut response = response;
4334        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4335        proto::json::ResponsePayload::new(&response).deserialize::<PollForJobsOutput, _>()
4336    }
4337
4338    /// <p><p>Determines whether there are any third party jobs for a job worker to act on. Used for partner actions only.</p> <important> <p>When this API is called, AWS CodePipeline returns temporary credentials for the S3 bucket used to store artifacts for the pipeline, if the action requires access to that S3 bucket for input or output artifacts.</p> </important></p>
4339    async fn poll_for_third_party_jobs(
4340        &self,
4341        input: PollForThirdPartyJobsInput,
4342    ) -> Result<PollForThirdPartyJobsOutput, RusotoError<PollForThirdPartyJobsError>> {
4343        let mut request = self.new_signed_request("POST", "/");
4344        request.add_header(
4345            "x-amz-target",
4346            "CodePipeline_20150709.PollForThirdPartyJobs",
4347        );
4348        let encoded = serde_json::to_string(&input).unwrap();
4349        request.set_payload(Some(encoded));
4350
4351        let response = self
4352            .sign_and_dispatch(request, PollForThirdPartyJobsError::from_response)
4353            .await?;
4354        let mut response = response;
4355        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4356        proto::json::ResponsePayload::new(&response).deserialize::<PollForThirdPartyJobsOutput, _>()
4357    }
4358
4359    /// <p>Provides information to AWS CodePipeline about new revisions to a source.</p>
4360    async fn put_action_revision(
4361        &self,
4362        input: PutActionRevisionInput,
4363    ) -> Result<PutActionRevisionOutput, RusotoError<PutActionRevisionError>> {
4364        let mut request = self.new_signed_request("POST", "/");
4365        request.add_header("x-amz-target", "CodePipeline_20150709.PutActionRevision");
4366        let encoded = serde_json::to_string(&input).unwrap();
4367        request.set_payload(Some(encoded));
4368
4369        let response = self
4370            .sign_and_dispatch(request, PutActionRevisionError::from_response)
4371            .await?;
4372        let mut response = response;
4373        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4374        proto::json::ResponsePayload::new(&response).deserialize::<PutActionRevisionOutput, _>()
4375    }
4376
4377    /// <p>Provides the response to a manual approval request to AWS CodePipeline. Valid responses include Approved and Rejected.</p>
4378    async fn put_approval_result(
4379        &self,
4380        input: PutApprovalResultInput,
4381    ) -> Result<PutApprovalResultOutput, RusotoError<PutApprovalResultError>> {
4382        let mut request = self.new_signed_request("POST", "/");
4383        request.add_header("x-amz-target", "CodePipeline_20150709.PutApprovalResult");
4384        let encoded = serde_json::to_string(&input).unwrap();
4385        request.set_payload(Some(encoded));
4386
4387        let response = self
4388            .sign_and_dispatch(request, PutApprovalResultError::from_response)
4389            .await?;
4390        let mut response = response;
4391        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4392        proto::json::ResponsePayload::new(&response).deserialize::<PutApprovalResultOutput, _>()
4393    }
4394
4395    /// <p>Represents the failure of a job as returned to the pipeline by a job worker. Used for custom actions only.</p>
4396    async fn put_job_failure_result(
4397        &self,
4398        input: PutJobFailureResultInput,
4399    ) -> Result<(), RusotoError<PutJobFailureResultError>> {
4400        let mut request = self.new_signed_request("POST", "/");
4401        request.add_header("x-amz-target", "CodePipeline_20150709.PutJobFailureResult");
4402        let encoded = serde_json::to_string(&input).unwrap();
4403        request.set_payload(Some(encoded));
4404
4405        let response = self
4406            .sign_and_dispatch(request, PutJobFailureResultError::from_response)
4407            .await?;
4408        std::mem::drop(response);
4409        Ok(())
4410    }
4411
4412    /// <p>Represents the success of a job as returned to the pipeline by a job worker. Used for custom actions only.</p>
4413    async fn put_job_success_result(
4414        &self,
4415        input: PutJobSuccessResultInput,
4416    ) -> Result<(), RusotoError<PutJobSuccessResultError>> {
4417        let mut request = self.new_signed_request("POST", "/");
4418        request.add_header("x-amz-target", "CodePipeline_20150709.PutJobSuccessResult");
4419        let encoded = serde_json::to_string(&input).unwrap();
4420        request.set_payload(Some(encoded));
4421
4422        let response = self
4423            .sign_and_dispatch(request, PutJobSuccessResultError::from_response)
4424            .await?;
4425        std::mem::drop(response);
4426        Ok(())
4427    }
4428
4429    /// <p>Represents the failure of a third party job as returned to the pipeline by a job worker. Used for partner actions only.</p>
4430    async fn put_third_party_job_failure_result(
4431        &self,
4432        input: PutThirdPartyJobFailureResultInput,
4433    ) -> Result<(), RusotoError<PutThirdPartyJobFailureResultError>> {
4434        let mut request = self.new_signed_request("POST", "/");
4435        request.add_header(
4436            "x-amz-target",
4437            "CodePipeline_20150709.PutThirdPartyJobFailureResult",
4438        );
4439        let encoded = serde_json::to_string(&input).unwrap();
4440        request.set_payload(Some(encoded));
4441
4442        let response = self
4443            .sign_and_dispatch(request, PutThirdPartyJobFailureResultError::from_response)
4444            .await?;
4445        std::mem::drop(response);
4446        Ok(())
4447    }
4448
4449    /// <p>Represents the success of a third party job as returned to the pipeline by a job worker. Used for partner actions only.</p>
4450    async fn put_third_party_job_success_result(
4451        &self,
4452        input: PutThirdPartyJobSuccessResultInput,
4453    ) -> Result<(), RusotoError<PutThirdPartyJobSuccessResultError>> {
4454        let mut request = self.new_signed_request("POST", "/");
4455        request.add_header(
4456            "x-amz-target",
4457            "CodePipeline_20150709.PutThirdPartyJobSuccessResult",
4458        );
4459        let encoded = serde_json::to_string(&input).unwrap();
4460        request.set_payload(Some(encoded));
4461
4462        let response = self
4463            .sign_and_dispatch(request, PutThirdPartyJobSuccessResultError::from_response)
4464            .await?;
4465        std::mem::drop(response);
4466        Ok(())
4467    }
4468
4469    /// <p>Defines a webhook and returns a unique webhook URL generated by CodePipeline. This URL can be supplied to third party source hosting providers to call every time there's a code change. When CodePipeline receives a POST request on this URL, the pipeline defined in the webhook is started as long as the POST request satisfied the authentication and filtering requirements supplied when defining the webhook. RegisterWebhookWithThirdParty and DeregisterWebhookWithThirdParty APIs can be used to automatically configure supported third parties to call the generated webhook URL.</p>
4470    async fn put_webhook(
4471        &self,
4472        input: PutWebhookInput,
4473    ) -> Result<PutWebhookOutput, RusotoError<PutWebhookError>> {
4474        let mut request = self.new_signed_request("POST", "/");
4475        request.add_header("x-amz-target", "CodePipeline_20150709.PutWebhook");
4476        let encoded = serde_json::to_string(&input).unwrap();
4477        request.set_payload(Some(encoded));
4478
4479        let response = self
4480            .sign_and_dispatch(request, PutWebhookError::from_response)
4481            .await?;
4482        let mut response = response;
4483        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4484        proto::json::ResponsePayload::new(&response).deserialize::<PutWebhookOutput, _>()
4485    }
4486
4487    /// <p>Configures a connection between the webhook that was created and the external tool with events to be detected.</p>
4488    async fn register_webhook_with_third_party(
4489        &self,
4490        input: RegisterWebhookWithThirdPartyInput,
4491    ) -> Result<RegisterWebhookWithThirdPartyOutput, RusotoError<RegisterWebhookWithThirdPartyError>>
4492    {
4493        let mut request = self.new_signed_request("POST", "/");
4494        request.add_header(
4495            "x-amz-target",
4496            "CodePipeline_20150709.RegisterWebhookWithThirdParty",
4497        );
4498        let encoded = serde_json::to_string(&input).unwrap();
4499        request.set_payload(Some(encoded));
4500
4501        let response = self
4502            .sign_and_dispatch(request, RegisterWebhookWithThirdPartyError::from_response)
4503            .await?;
4504        let mut response = response;
4505        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4506        proto::json::ResponsePayload::new(&response)
4507            .deserialize::<RegisterWebhookWithThirdPartyOutput, _>()
4508    }
4509
4510    /// <p>Resumes the pipeline execution by retrying the last failed actions in a stage. You can retry a stage immediately if any of the actions in the stage fail. When you retry, all actions that are still in progress continue working, and failed actions are triggered again.</p>
4511    async fn retry_stage_execution(
4512        &self,
4513        input: RetryStageExecutionInput,
4514    ) -> Result<RetryStageExecutionOutput, RusotoError<RetryStageExecutionError>> {
4515        let mut request = self.new_signed_request("POST", "/");
4516        request.add_header("x-amz-target", "CodePipeline_20150709.RetryStageExecution");
4517        let encoded = serde_json::to_string(&input).unwrap();
4518        request.set_payload(Some(encoded));
4519
4520        let response = self
4521            .sign_and_dispatch(request, RetryStageExecutionError::from_response)
4522            .await?;
4523        let mut response = response;
4524        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4525        proto::json::ResponsePayload::new(&response).deserialize::<RetryStageExecutionOutput, _>()
4526    }
4527
4528    /// <p>Starts the specified pipeline. Specifically, it begins processing the latest commit to the source location specified as part of the pipeline.</p>
4529    async fn start_pipeline_execution(
4530        &self,
4531        input: StartPipelineExecutionInput,
4532    ) -> Result<StartPipelineExecutionOutput, RusotoError<StartPipelineExecutionError>> {
4533        let mut request = self.new_signed_request("POST", "/");
4534        request.add_header(
4535            "x-amz-target",
4536            "CodePipeline_20150709.StartPipelineExecution",
4537        );
4538        let encoded = serde_json::to_string(&input).unwrap();
4539        request.set_payload(Some(encoded));
4540
4541        let response = self
4542            .sign_and_dispatch(request, StartPipelineExecutionError::from_response)
4543            .await?;
4544        let mut response = response;
4545        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4546        proto::json::ResponsePayload::new(&response)
4547            .deserialize::<StartPipelineExecutionOutput, _>()
4548    }
4549
4550    /// <p>Stops the specified pipeline execution. You choose to either stop the pipeline execution by completing in-progress actions without starting subsequent actions, or by abandoning in-progress actions. While completing or abandoning in-progress actions, the pipeline execution is in a <code>Stopping</code> state. After all in-progress actions are completed or abandoned, the pipeline execution is in a <code>Stopped</code> state.</p>
4551    async fn stop_pipeline_execution(
4552        &self,
4553        input: StopPipelineExecutionInput,
4554    ) -> Result<StopPipelineExecutionOutput, RusotoError<StopPipelineExecutionError>> {
4555        let mut request = self.new_signed_request("POST", "/");
4556        request.add_header(
4557            "x-amz-target",
4558            "CodePipeline_20150709.StopPipelineExecution",
4559        );
4560        let encoded = serde_json::to_string(&input).unwrap();
4561        request.set_payload(Some(encoded));
4562
4563        let response = self
4564            .sign_and_dispatch(request, StopPipelineExecutionError::from_response)
4565            .await?;
4566        let mut response = response;
4567        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4568        proto::json::ResponsePayload::new(&response).deserialize::<StopPipelineExecutionOutput, _>()
4569    }
4570
4571    /// <p>Adds to or modifies the tags of the given resource. Tags are metadata that can be used to manage a resource. </p>
4572    async fn tag_resource(
4573        &self,
4574        input: TagResourceInput,
4575    ) -> Result<TagResourceOutput, RusotoError<TagResourceError>> {
4576        let mut request = self.new_signed_request("POST", "/");
4577        request.add_header("x-amz-target", "CodePipeline_20150709.TagResource");
4578        let encoded = serde_json::to_string(&input).unwrap();
4579        request.set_payload(Some(encoded));
4580
4581        let response = self
4582            .sign_and_dispatch(request, TagResourceError::from_response)
4583            .await?;
4584        let mut response = response;
4585        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4586        proto::json::ResponsePayload::new(&response).deserialize::<TagResourceOutput, _>()
4587    }
4588
4589    /// <p>Removes tags from an AWS resource.</p>
4590    async fn untag_resource(
4591        &self,
4592        input: UntagResourceInput,
4593    ) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>> {
4594        let mut request = self.new_signed_request("POST", "/");
4595        request.add_header("x-amz-target", "CodePipeline_20150709.UntagResource");
4596        let encoded = serde_json::to_string(&input).unwrap();
4597        request.set_payload(Some(encoded));
4598
4599        let response = self
4600            .sign_and_dispatch(request, UntagResourceError::from_response)
4601            .await?;
4602        let mut response = response;
4603        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4604        proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceOutput, _>()
4605    }
4606
4607    /// <p>Updates a specified pipeline with edits or changes to its structure. Use a JSON file with the pipeline structure and <code>UpdatePipeline</code> to provide the full structure of the pipeline. Updating the pipeline increases the version number of the pipeline by 1.</p>
4608    async fn update_pipeline(
4609        &self,
4610        input: UpdatePipelineInput,
4611    ) -> Result<UpdatePipelineOutput, RusotoError<UpdatePipelineError>> {
4612        let mut request = self.new_signed_request("POST", "/");
4613        request.add_header("x-amz-target", "CodePipeline_20150709.UpdatePipeline");
4614        let encoded = serde_json::to_string(&input).unwrap();
4615        request.set_payload(Some(encoded));
4616
4617        let response = self
4618            .sign_and_dispatch(request, UpdatePipelineError::from_response)
4619            .await?;
4620        let mut response = response;
4621        let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
4622        proto::json::ResponsePayload::new(&response).deserialize::<UpdatePipelineOutput, _>()
4623    }
4624}
rusoto_codepipeline/generated.rs

rusoto_codepipeline/
generated.rs
