AWS SDK

AWS SDK

rev. 18b1dd205ff4335251e6dd0ecb88193de1b1cede (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ssm/src/types/_signal_type.rs

@@ -0,1 +0,132 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// When writing a match expression against `SignalType`, it is important to ensure
           4  +
/// your code is forward-compatible. That is, if a match arm handles a case for a
           5  +
/// feature that is supported by the service but has not been represented as an enum
           6  +
/// variant in a current version of SDK, your code should continue to work when you
           7  +
/// upgrade SDK to a future version in which the enum does include a variant for that
           8  +
/// feature.
           9  +
///
          10  +
/// Here is an example of how you can make a match expression forward-compatible:
          11  +
///
          12  +
/// ```text
          13  +
/// # let signaltype = unimplemented!();
          14  +
/// match signaltype {
          15  +
///     SignalType::Approve => { /* ... */ },
          16  +
///     SignalType::Reject => { /* ... */ },
          17  +
///     SignalType::Resume => { /* ... */ },
          18  +
///     SignalType::Revoke => { /* ... */ },
          19  +
///     SignalType::StartStep => { /* ... */ },
          20  +
///     SignalType::StopStep => { /* ... */ },
          21  +
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
          22  +
///     _ => { /* ... */ },
          23  +
/// }
          24  +
/// ```
          25  +
/// The above code demonstrates that when `signaltype` represents
          26  +
/// `NewFeature`, the execution path will lead to the second last match arm,
          27  +
/// even though the enum does not contain a variant `SignalType::NewFeature`
          28  +
/// in the current version of SDK. The reason is that the variable `other`,
          29  +
/// created by the `@` operator, is bound to
          30  +
/// `SignalType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
          31  +
/// and calling `as_str` on it yields `"NewFeature"`.
          32  +
/// This match expression is forward-compatible when executed with a newer
          33  +
/// version of SDK where the variant `SignalType::NewFeature` is defined.
          34  +
/// Specifically, when `signaltype` represents `NewFeature`,
          35  +
/// the execution path will hit the second last match arm as before by virtue of
          36  +
/// calling `as_str` on `SignalType::NewFeature` also yielding `"NewFeature"`.
          37  +
///
          38  +
/// Explicitly matching on the `Unknown` variant should
          39  +
/// be avoided for two reasons:
          40  +
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
          41  +
/// - It might inadvertently shadow other intended match arms.
          42  +
///
          43  +
#[allow(missing_docs)] // documentation missing in model
          44  +
#[non_exhaustive]
          45  +
#[derive(
          46  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
          47  +
)]
          48  +
pub enum SignalType {
          49  +
    #[allow(missing_docs)] // documentation missing in model
          50  +
    Approve,
          51  +
    #[allow(missing_docs)] // documentation missing in model
          52  +
    Reject,
          53  +
    #[allow(missing_docs)] // documentation missing in model
          54  +
    Resume,
          55  +
    #[allow(missing_docs)] // documentation missing in model
          56  +
    Revoke,
          57  +
    #[allow(missing_docs)] // documentation missing in model
          58  +
    StartStep,
          59  +
    #[allow(missing_docs)] // documentation missing in model
          60  +
    StopStep,
          61  +
    /// `Unknown` contains new variants that have been added since this code was generated.
          62  +
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
          63  +
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
          64  +
}
          65  +
impl ::std::convert::From<&str> for SignalType {
          66  +
    fn from(s: &str) -> Self {
          67  +
        match s {
          68  +
            "Approve" => SignalType::Approve,
          69  +
            "Reject" => SignalType::Reject,
          70  +
            "Resume" => SignalType::Resume,
          71  +
            "Revoke" => SignalType::Revoke,
          72  +
            "StartStep" => SignalType::StartStep,
          73  +
            "StopStep" => SignalType::StopStep,
          74  +
            other => SignalType::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
          75  +
        }
          76  +
    }
          77  +
}
          78  +
impl ::std::str::FromStr for SignalType {
          79  +
    type Err = ::std::convert::Infallible;
          80  +
          81  +
    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
          82  +
        ::std::result::Result::Ok(SignalType::from(s))
          83  +
    }
          84  +
}
          85  +
impl SignalType {
          86  +
    /// Returns the `&str` value of the enum member.
          87  +
    pub fn as_str(&self) -> &str {
          88  +
        match self {
          89  +
            SignalType::Approve => "Approve",
          90  +
            SignalType::Reject => "Reject",
          91  +
            SignalType::Resume => "Resume",
          92  +
            SignalType::Revoke => "Revoke",
          93  +
            SignalType::StartStep => "StartStep",
          94  +
            SignalType::StopStep => "StopStep",
          95  +
            SignalType::Unknown(value) => value.as_str(),
          96  +
        }
          97  +
    }
          98  +
    /// Returns all the `&str` representations of the enum members.
          99  +
    pub const fn values() -> &'static [&'static str] {
         100  +
        &["Approve", "Reject", "Resume", "Revoke", "StartStep", "StopStep"]
         101  +
    }
         102  +
}
         103  +
impl ::std::convert::AsRef<str> for SignalType {
         104  +
    fn as_ref(&self) -> &str {
         105  +
        self.as_str()
         106  +
    }
         107  +
}
         108  +
impl SignalType {
         109  +
    /// Parses the enum value while disallowing unknown variants.
         110  +
    ///
         111  +
    /// Unknown variants will result in an error.
         112  +
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         113  +
        match Self::from(value) {
         114  +
            #[allow(deprecated)]
         115  +
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
         116  +
            known => Ok(known),
         117  +
        }
         118  +
    }
         119  +
}
         120  +
impl ::std::fmt::Display for SignalType {
         121  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         122  +
        match self {
         123  +
            SignalType::Approve => write!(f, "Approve"),
         124  +
            SignalType::Reject => write!(f, "Reject"),
         125  +
            SignalType::Resume => write!(f, "Resume"),
         126  +
            SignalType::Revoke => write!(f, "Revoke"),
         127  +
            SignalType::StartStep => write!(f, "StartStep"),
         128  +
            SignalType::StopStep => write!(f, "StopStep"),
         129  +
            SignalType::Unknown(value) => write!(f, "{value}"),
         130  +
        }
         131  +
    }
         132  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/types/_source_type.rs

@@ -0,1 +0,125 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// When writing a match expression against `SourceType`, it is important to ensure
           4  +
/// your code is forward-compatible. That is, if a match arm handles a case for a
           5  +
/// feature that is supported by the service but has not been represented as an enum
           6  +
/// variant in a current version of SDK, your code should continue to work when you
           7  +
/// upgrade SDK to a future version in which the enum does include a variant for that
           8  +
/// feature.
           9  +
///
          10  +
/// Here is an example of how you can make a match expression forward-compatible:
          11  +
///
          12  +
/// ```text
          13  +
/// # let sourcetype = unimplemented!();
          14  +
/// match sourcetype {
          15  +
///     SourceType::AwsEc2Instance => { /* ... */ },
          16  +
///     SourceType::AwsIotThing => { /* ... */ },
          17  +
///     SourceType::AwsSsmManagedinstance => { /* ... */ },
          18  +
///     SourceType::AzureInstance => { /* ... */ },
          19  +
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
          20  +
///     _ => { /* ... */ },
          21  +
/// }
          22  +
/// ```
          23  +
/// The above code demonstrates that when `sourcetype` represents
          24  +
/// `NewFeature`, the execution path will lead to the second last match arm,
          25  +
/// even though the enum does not contain a variant `SourceType::NewFeature`
          26  +
/// in the current version of SDK. The reason is that the variable `other`,
          27  +
/// created by the `@` operator, is bound to
          28  +
/// `SourceType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
          29  +
/// and calling `as_str` on it yields `"NewFeature"`.
          30  +
/// This match expression is forward-compatible when executed with a newer
          31  +
/// version of SDK where the variant `SourceType::NewFeature` is defined.
          32  +
/// Specifically, when `sourcetype` represents `NewFeature`,
          33  +
/// the execution path will hit the second last match arm as before by virtue of
          34  +
/// calling `as_str` on `SourceType::NewFeature` also yielding `"NewFeature"`.
          35  +
///
          36  +
/// Explicitly matching on the `Unknown` variant should
          37  +
/// be avoided for two reasons:
          38  +
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
          39  +
/// - It might inadvertently shadow other intended match arms.
          40  +
///
          41  +
#[allow(missing_docs)] // documentation missing in model
          42  +
#[non_exhaustive]
          43  +
#[derive(
          44  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
          45  +
)]
          46  +
pub enum SourceType {
          47  +
    #[allow(missing_docs)] // documentation missing in model
          48  +
    AwsEc2Instance,
          49  +
    #[allow(missing_docs)] // documentation missing in model
          50  +
    AwsIotThing,
          51  +
    #[allow(missing_docs)] // documentation missing in model
          52  +
    AwsSsmManagedinstance,
          53  +
    #[allow(missing_docs)] // documentation missing in model
          54  +
    AzureInstance,
          55  +
    /// `Unknown` contains new variants that have been added since this code was generated.
          56  +
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
          57  +
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
          58  +
}
          59  +
impl ::std::convert::From<&str> for SourceType {
          60  +
    fn from(s: &str) -> Self {
          61  +
        match s {
          62  +
            "AWS::EC2::Instance" => SourceType::AwsEc2Instance,
          63  +
            "AWS::IoT::Thing" => SourceType::AwsIotThing,
          64  +
            "AWS::SSM::ManagedInstance" => SourceType::AwsSsmManagedinstance,
          65  +
            "Microsoft.Compute/virtualMachines" => SourceType::AzureInstance,
          66  +
            other => SourceType::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
          67  +
        }
          68  +
    }
          69  +
}
          70  +
impl ::std::str::FromStr for SourceType {
          71  +
    type Err = ::std::convert::Infallible;
          72  +
          73  +
    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
          74  +
        ::std::result::Result::Ok(SourceType::from(s))
          75  +
    }
          76  +
}
          77  +
impl SourceType {
          78  +
    /// Returns the `&str` value of the enum member.
          79  +
    pub fn as_str(&self) -> &str {
          80  +
        match self {
          81  +
            SourceType::AwsEc2Instance => "AWS::EC2::Instance",
          82  +
            SourceType::AwsIotThing => "AWS::IoT::Thing",
          83  +
            SourceType::AwsSsmManagedinstance => "AWS::SSM::ManagedInstance",
          84  +
            SourceType::AzureInstance => "Microsoft.Compute/virtualMachines",
          85  +
            SourceType::Unknown(value) => value.as_str(),
          86  +
        }
          87  +
    }
          88  +
    /// Returns all the `&str` representations of the enum members.
          89  +
    pub const fn values() -> &'static [&'static str] {
          90  +
        &[
          91  +
            "AWS::EC2::Instance",
          92  +
            "AWS::IoT::Thing",
          93  +
            "AWS::SSM::ManagedInstance",
          94  +
            "Microsoft.Compute/virtualMachines",
          95  +
        ]
          96  +
    }
          97  +
}
          98  +
impl ::std::convert::AsRef<str> for SourceType {
          99  +
    fn as_ref(&self) -> &str {
         100  +
        self.as_str()
         101  +
    }
         102  +
}
         103  +
impl SourceType {
         104  +
    /// Parses the enum value while disallowing unknown variants.
         105  +
    ///
         106  +
    /// Unknown variants will result in an error.
         107  +
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         108  +
        match Self::from(value) {
         109  +
            #[allow(deprecated)]
         110  +
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
         111  +
            known => Ok(known),
         112  +
        }
         113  +
    }
         114  +
}
         115  +
impl ::std::fmt::Display for SourceType {
         116  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         117  +
        match self {
         118  +
            SourceType::AwsEc2Instance => write!(f, "AWS::EC2::Instance"),
         119  +
            SourceType::AwsIotThing => write!(f, "AWS::IoT::Thing"),
         120  +
            SourceType::AwsSsmManagedinstance => write!(f, "AWS::SSM::ManagedInstance"),
         121  +
            SourceType::AzureInstance => write!(f, "Microsoft.Compute/virtualMachines"),
         122  +
            SourceType::Unknown(value) => write!(f, "{value}"),
         123  +
        }
         124  +
    }
         125  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/types/_step_execution.rs

@@ -0,1 +0,1329 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Detailed information about an the execution state of an Automation step.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct StepExecution {
           7  +
    /// <p>The name of this execution step.</p>
           8  +
    pub step_name: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>The action this step performs. The action determines the behavior of the step.</p>
          10  +
    pub action: ::std::option::Option<::std::string::String>,
          11  +
    /// <p>The timeout seconds of the step.</p>
          12  +
    pub timeout_seconds: ::std::option::Option<i64>,
          13  +
    /// <p>The action to take if the step fails. The default value is <code>Abort</code>.</p>
          14  +
    pub on_failure: ::std::option::Option<::std::string::String>,
          15  +
    /// <p>The maximum number of tries to run the action of the step. The default value is <code>1</code>.</p>
          16  +
    pub max_attempts: ::std::option::Option<i32>,
          17  +
    /// <p>If a step has begun execution, this contains the time the step started. If the step is in Pending status, this field isn't populated.</p>
          18  +
    pub execution_start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          19  +
    /// <p>If a step has finished execution, this contains the time the execution ended. If the step hasn't yet concluded, this field isn't populated.</p>
          20  +
    pub execution_end_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          21  +
    /// <p>The execution status for this step.</p>
          22  +
    pub step_status: ::std::option::Option<crate::types::AutomationExecutionStatus>,
          23  +
    /// <p>The response code returned by the execution of the step.</p>
          24  +
    pub response_code: ::std::option::Option<::std::string::String>,
          25  +
    /// <p>Fully-resolved values passed into the step before execution.</p>
          26  +
    pub inputs: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
          27  +
    /// <p>Returned values from the execution of the step.</p>
          28  +
    pub outputs: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
          29  +
    /// <p>A message associated with the response code for an execution.</p>
          30  +
    pub response: ::std::option::Option<::std::string::String>,
          31  +
    /// <p>If a step failed, this message explains why the execution failed.</p>
          32  +
    pub failure_message: ::std::option::Option<::std::string::String>,
          33  +
    /// <p>A message that describes a non-critical issue that occurred during the step execution. Present only if the step status includes a warning.</p>
          34  +
    pub warning_message: ::std::option::Option<::std::string::String>,
          35  +
    /// <p>Information about the Automation failure.</p>
          36  +
    pub failure_details: ::std::option::Option<crate::types::FailureDetails>,
          37  +
    /// <p>The unique ID of a step execution.</p>
          38  +
    pub step_execution_id: ::std::option::Option<::std::string::String>,
          39  +
    /// <p>A user-specified list of parameters to override when running a step.</p>
          40  +
    pub overridden_parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
          41  +
    /// <p>The flag which can be used to end automation no matter whether the step succeeds or fails.</p>
          42  +
    pub is_end: ::std::option::Option<bool>,
          43  +
    /// <p>The next step after the step succeeds.</p>
          44  +
    pub next_step: ::std::option::Option<::std::string::String>,
          45  +
    /// <p>The flag which can be used to help decide whether the failure of current step leads to the Automation failure.</p>
          46  +
    pub is_critical: ::std::option::Option<bool>,
          47  +
    /// <p>Strategies used when step fails, we support Continue and Abort. Abort will fail the automation when the step fails. Continue will ignore the failure of current step and allow automation to run the next step. With conditional branching, we add step:stepName to support the automation to go to another specific step.</p>
          48  +
    pub valid_next_steps: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          49  +
    /// <p>The targets for the step execution.</p>
          50  +
    pub targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
          51  +
    /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts targeted by the current Automation execution.</p>
          52  +
    pub target_location: ::std::option::Option<crate::types::TargetLocation>,
          53  +
    /// <p>The CloudWatch alarms that were invoked by the automation.</p>
          54  +
    pub triggered_alarms: ::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>>,
          55  +
    /// <p>Information about the parent step.</p>
          56  +
    pub parent_step_details: ::std::option::Option<crate::types::ParentStepDetails>,
          57  +
}
          58  +
impl StepExecution {
          59  +
    /// <p>The name of this execution step.</p>
          60  +
    pub fn step_name(&self) -> ::std::option::Option<&str> {
          61  +
        self.step_name.as_deref()
          62  +
    }
          63  +
    /// <p>The action this step performs. The action determines the behavior of the step.</p>
          64  +
    pub fn action(&self) -> ::std::option::Option<&str> {
          65  +
        self.action.as_deref()
          66  +
    }
          67  +
    /// <p>The timeout seconds of the step.</p>
          68  +
    pub fn timeout_seconds(&self) -> ::std::option::Option<i64> {
          69  +
        self.timeout_seconds
          70  +
    }
          71  +
    /// <p>The action to take if the step fails. The default value is <code>Abort</code>.</p>
          72  +
    pub fn on_failure(&self) -> ::std::option::Option<&str> {
          73  +
        self.on_failure.as_deref()
          74  +
    }
          75  +
    /// <p>The maximum number of tries to run the action of the step. The default value is <code>1</code>.</p>
          76  +
    pub fn max_attempts(&self) -> ::std::option::Option<i32> {
          77  +
        self.max_attempts
          78  +
    }
          79  +
    /// <p>If a step has begun execution, this contains the time the step started. If the step is in Pending status, this field isn't populated.</p>
          80  +
    pub fn execution_start_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          81  +
        self.execution_start_time.as_ref()
          82  +
    }
          83  +
    /// <p>If a step has finished execution, this contains the time the execution ended. If the step hasn't yet concluded, this field isn't populated.</p>
          84  +
    pub fn execution_end_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          85  +
        self.execution_end_time.as_ref()
          86  +
    }
          87  +
    /// <p>The execution status for this step.</p>
          88  +
    pub fn step_status(&self) -> ::std::option::Option<&crate::types::AutomationExecutionStatus> {
          89  +
        self.step_status.as_ref()
          90  +
    }
          91  +
    /// <p>The response code returned by the execution of the step.</p>
          92  +
    pub fn response_code(&self) -> ::std::option::Option<&str> {
          93  +
        self.response_code.as_deref()
          94  +
    }
          95  +
    /// <p>Fully-resolved values passed into the step before execution.</p>
          96  +
    pub fn inputs(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
          97  +
        self.inputs.as_ref()
          98  +
    }
          99  +
    /// <p>Returned values from the execution of the step.</p>
         100  +
    pub fn outputs(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         101  +
        self.outputs.as_ref()
         102  +
    }
         103  +
    /// <p>A message associated with the response code for an execution.</p>
         104  +
    pub fn response(&self) -> ::std::option::Option<&str> {
         105  +
        self.response.as_deref()
         106  +
    }
         107  +
    /// <p>If a step failed, this message explains why the execution failed.</p>
         108  +
    pub fn failure_message(&self) -> ::std::option::Option<&str> {
         109  +
        self.failure_message.as_deref()
         110  +
    }
         111  +
    /// <p>A message that describes a non-critical issue that occurred during the step execution. Present only if the step status includes a warning.</p>
         112  +
    pub fn warning_message(&self) -> ::std::option::Option<&str> {
         113  +
        self.warning_message.as_deref()
         114  +
    }
         115  +
    /// <p>Information about the Automation failure.</p>
         116  +
    pub fn failure_details(&self) -> ::std::option::Option<&crate::types::FailureDetails> {
         117  +
        self.failure_details.as_ref()
         118  +
    }
         119  +
    /// <p>The unique ID of a step execution.</p>
         120  +
    pub fn step_execution_id(&self) -> ::std::option::Option<&str> {
         121  +
        self.step_execution_id.as_deref()
         122  +
    }
         123  +
    /// <p>A user-specified list of parameters to override when running a step.</p>
         124  +
    pub fn overridden_parameters(
         125  +
        &self,
         126  +
    ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         127  +
        self.overridden_parameters.as_ref()
         128  +
    }
         129  +
    /// <p>The flag which can be used to end automation no matter whether the step succeeds or fails.</p>
         130  +
    pub fn is_end(&self) -> ::std::option::Option<bool> {
         131  +
        self.is_end
         132  +
    }
         133  +
    /// <p>The next step after the step succeeds.</p>
         134  +
    pub fn next_step(&self) -> ::std::option::Option<&str> {
         135  +
        self.next_step.as_deref()
         136  +
    }
         137  +
    /// <p>The flag which can be used to help decide whether the failure of current step leads to the Automation failure.</p>
         138  +
    pub fn is_critical(&self) -> ::std::option::Option<bool> {
         139  +
        self.is_critical
         140  +
    }
         141  +
    /// <p>Strategies used when step fails, we support Continue and Abort. Abort will fail the automation when the step fails. Continue will ignore the failure of current step and allow automation to run the next step. With conditional branching, we add step:stepName to support the automation to go to another specific step.</p>
         142  +
    ///
         143  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.valid_next_steps.is_none()`.
         144  +
    pub fn valid_next_steps(&self) -> &[::std::string::String] {
         145  +
        self.valid_next_steps.as_deref().unwrap_or_default()
         146  +
    }
         147  +
    /// <p>The targets for the step execution.</p>
         148  +
    ///
         149  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.targets.is_none()`.
         150  +
    pub fn targets(&self) -> &[crate::types::Target] {
         151  +
        self.targets.as_deref().unwrap_or_default()
         152  +
    }
         153  +
    /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts targeted by the current Automation execution.</p>
         154  +
    pub fn target_location(&self) -> ::std::option::Option<&crate::types::TargetLocation> {
         155  +
        self.target_location.as_ref()
         156  +
    }
         157  +
    /// <p>The CloudWatch alarms that were invoked by the automation.</p>
         158  +
    ///
         159  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.triggered_alarms.is_none()`.
         160  +
    pub fn triggered_alarms(&self) -> &[crate::types::AlarmStateInformation] {
         161  +
        self.triggered_alarms.as_deref().unwrap_or_default()
         162  +
    }
         163  +
    /// <p>Information about the parent step.</p>
         164  +
    pub fn parent_step_details(&self) -> ::std::option::Option<&crate::types::ParentStepDetails> {
         165  +
        self.parent_step_details.as_ref()
         166  +
    }
         167  +
}
         168  +
static STEPEXECUTION_MEMBER_STEP_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         169  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$StepName", "com.amazonaws.ssm", "StepExecution"),
         170  +
    ::aws_smithy_schema::ShapeType::String,
         171  +
    "StepName",
         172  +
    0,
         173  +
);
         174  +
static STEPEXECUTION_MEMBER_ACTION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         175  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$Action", "com.amazonaws.ssm", "StepExecution"),
         176  +
    ::aws_smithy_schema::ShapeType::String,
         177  +
    "Action",
         178  +
    1,
         179  +
);
         180  +
static STEPEXECUTION_MEMBER_TIMEOUT_SECONDS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         181  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$TimeoutSeconds", "com.amazonaws.ssm", "StepExecution"),
         182  +
    ::aws_smithy_schema::ShapeType::Long,
         183  +
    "TimeoutSeconds",
         184  +
    2,
         185  +
);
         186  +
static STEPEXECUTION_MEMBER_ON_FAILURE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         187  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$OnFailure", "com.amazonaws.ssm", "StepExecution"),
         188  +
    ::aws_smithy_schema::ShapeType::String,
         189  +
    "OnFailure",
         190  +
    3,
         191  +
);
         192  +
static STEPEXECUTION_MEMBER_MAX_ATTEMPTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         193  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$MaxAttempts", "com.amazonaws.ssm", "StepExecution"),
         194  +
    ::aws_smithy_schema::ShapeType::Integer,
         195  +
    "MaxAttempts",
         196  +
    4,
         197  +
);
         198  +
static STEPEXECUTION_MEMBER_EXECUTION_START_TIME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         199  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$ExecutionStartTime", "com.amazonaws.ssm", "StepExecution"),
         200  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         201  +
    "ExecutionStartTime",
         202  +
    5,
         203  +
);
         204  +
static STEPEXECUTION_MEMBER_EXECUTION_END_TIME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         205  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$ExecutionEndTime", "com.amazonaws.ssm", "StepExecution"),
         206  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         207  +
    "ExecutionEndTime",
         208  +
    6,
         209  +
);
         210  +
static STEPEXECUTION_MEMBER_STEP_STATUS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         211  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$StepStatus", "com.amazonaws.ssm", "StepExecution"),
         212  +
    ::aws_smithy_schema::ShapeType::String,
         213  +
    "StepStatus",
         214  +
    7,
         215  +
);
         216  +
static STEPEXECUTION_MEMBER_RESPONSE_CODE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         217  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$ResponseCode", "com.amazonaws.ssm", "StepExecution"),
         218  +
    ::aws_smithy_schema::ShapeType::String,
         219  +
    "ResponseCode",
         220  +
    8,
         221  +
);
         222  +
static STEPEXECUTION_MEMBER_INPUTS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         223  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#NormalStringMap$key", "com.amazonaws.ssm", "NormalStringMap"),
         224  +
    ::aws_smithy_schema::ShapeType::String,
         225  +
    "key",
         226  +
    0,
         227  +
);
         228  +
static STEPEXECUTION_MEMBER_INPUTS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         229  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#NormalStringMap$value", "com.amazonaws.ssm", "NormalStringMap"),
         230  +
    ::aws_smithy_schema::ShapeType::String,
         231  +
    "value",
         232  +
    1,
         233  +
);
         234  +
static STEPEXECUTION_MEMBER_INPUTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         235  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$Inputs", "com.amazonaws.ssm", "StepExecution"),
         236  +
    ::aws_smithy_schema::ShapeType::Map,
         237  +
    "Inputs",
         238  +
    9,
         239  +
)
         240  +
.with_map_members(&STEPEXECUTION_MEMBER_INPUTS_KEY, &STEPEXECUTION_MEMBER_INPUTS_VALUE);
         241  +
static STEPEXECUTION_MEMBER_OUTPUTS_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         242  +
    ::aws_smithy_schema::ShapeId::from_parts(
         243  +
        "com.amazonaws.ssm#AutomationParameterValueList$member",
         244  +
        "com.amazonaws.ssm",
         245  +
        "AutomationParameterValueList",
         246  +
    ),
         247  +
    ::aws_smithy_schema::ShapeType::String,
         248  +
    "member",
         249  +
    0,
         250  +
);
         251  +
static STEPEXECUTION_MEMBER_OUTPUTS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         252  +
    ::aws_smithy_schema::ShapeId::from_parts(
         253  +
        "com.amazonaws.ssm#AutomationParameterMap$key",
         254  +
        "com.amazonaws.ssm",
         255  +
        "AutomationParameterMap",
         256  +
    ),
         257  +
    ::aws_smithy_schema::ShapeType::String,
         258  +
    "key",
         259  +
    0,
         260  +
);
         261  +
static STEPEXECUTION_MEMBER_OUTPUTS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         262  +
    ::aws_smithy_schema::ShapeId::from_parts(
         263  +
        "com.amazonaws.ssm#AutomationParameterMap$value",
         264  +
        "com.amazonaws.ssm",
         265  +
        "AutomationParameterMap",
         266  +
    ),
         267  +
    ::aws_smithy_schema::ShapeType::List,
         268  +
    "value",
         269  +
    1,
         270  +
)
         271  +
.with_list_member(&STEPEXECUTION_MEMBER_OUTPUTS_VALUE_MEMBER);
         272  +
static STEPEXECUTION_MEMBER_OUTPUTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         273  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$Outputs", "com.amazonaws.ssm", "StepExecution"),
         274  +
    ::aws_smithy_schema::ShapeType::Map,
         275  +
    "Outputs",
         276  +
    10,
         277  +
)
         278  +
.with_map_members(&STEPEXECUTION_MEMBER_OUTPUTS_KEY, &STEPEXECUTION_MEMBER_OUTPUTS_VALUE);
         279  +
static STEPEXECUTION_MEMBER_RESPONSE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         280  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$Response", "com.amazonaws.ssm", "StepExecution"),
         281  +
    ::aws_smithy_schema::ShapeType::String,
         282  +
    "Response",
         283  +
    11,
         284  +
);
         285  +
static STEPEXECUTION_MEMBER_FAILURE_MESSAGE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         286  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$FailureMessage", "com.amazonaws.ssm", "StepExecution"),
         287  +
    ::aws_smithy_schema::ShapeType::String,
         288  +
    "FailureMessage",
         289  +
    12,
         290  +
);
         291  +
static STEPEXECUTION_MEMBER_WARNING_MESSAGE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         292  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$WarningMessage", "com.amazonaws.ssm", "StepExecution"),
         293  +
    ::aws_smithy_schema::ShapeType::String,
         294  +
    "WarningMessage",
         295  +
    13,
         296  +
);
         297  +
static STEPEXECUTION_MEMBER_FAILURE_DETAILS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         298  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$FailureDetails", "com.amazonaws.ssm", "StepExecution"),
         299  +
    ::aws_smithy_schema::ShapeType::Structure,
         300  +
    "FailureDetails",
         301  +
    14,
         302  +
);
         303  +
static STEPEXECUTION_MEMBER_STEP_EXECUTION_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         304  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$StepExecutionId", "com.amazonaws.ssm", "StepExecution"),
         305  +
    ::aws_smithy_schema::ShapeType::String,
         306  +
    "StepExecutionId",
         307  +
    15,
         308  +
);
         309  +
static STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         310  +
    ::aws_smithy_schema::ShapeId::from_parts(
         311  +
        "com.amazonaws.ssm#AutomationParameterValueList$member",
         312  +
        "com.amazonaws.ssm",
         313  +
        "AutomationParameterValueList",
         314  +
    ),
         315  +
    ::aws_smithy_schema::ShapeType::String,
         316  +
    "member",
         317  +
    0,
         318  +
);
         319  +
static STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         320  +
    ::aws_smithy_schema::ShapeId::from_parts(
         321  +
        "com.amazonaws.ssm#AutomationParameterMap$key",
         322  +
        "com.amazonaws.ssm",
         323  +
        "AutomationParameterMap",
         324  +
    ),
         325  +
    ::aws_smithy_schema::ShapeType::String,
         326  +
    "key",
         327  +
    0,
         328  +
);
         329  +
static STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         330  +
    ::aws_smithy_schema::ShapeId::from_parts(
         331  +
        "com.amazonaws.ssm#AutomationParameterMap$value",
         332  +
        "com.amazonaws.ssm",
         333  +
        "AutomationParameterMap",
         334  +
    ),
         335  +
    ::aws_smithy_schema::ShapeType::List,
         336  +
    "value",
         337  +
    1,
         338  +
)
         339  +
.with_list_member(&STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_VALUE_MEMBER);
         340  +
static STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         341  +
    ::aws_smithy_schema::ShapeId::from_parts(
         342  +
        "com.amazonaws.ssm#StepExecution$OverriddenParameters",
         343  +
        "com.amazonaws.ssm",
         344  +
        "StepExecution",
         345  +
    ),
         346  +
    ::aws_smithy_schema::ShapeType::Map,
         347  +
    "OverriddenParameters",
         348  +
    16,
         349  +
)
         350  +
.with_map_members(
         351  +
    &STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_KEY,
         352  +
    &STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_VALUE,
         353  +
);
         354  +
static STEPEXECUTION_MEMBER_IS_END: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         355  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$IsEnd", "com.amazonaws.ssm", "StepExecution"),
         356  +
    ::aws_smithy_schema::ShapeType::Boolean,
         357  +
    "IsEnd",
         358  +
    17,
         359  +
);
         360  +
static STEPEXECUTION_MEMBER_NEXT_STEP: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         361  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$NextStep", "com.amazonaws.ssm", "StepExecution"),
         362  +
    ::aws_smithy_schema::ShapeType::String,
         363  +
    "NextStep",
         364  +
    18,
         365  +
);
         366  +
static STEPEXECUTION_MEMBER_IS_CRITICAL: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         367  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$IsCritical", "com.amazonaws.ssm", "StepExecution"),
         368  +
    ::aws_smithy_schema::ShapeType::Boolean,
         369  +
    "IsCritical",
         370  +
    19,
         371  +
);
         372  +
static STEPEXECUTION_MEMBER_VALID_NEXT_STEPS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         373  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#ValidNextStepList$member", "com.amazonaws.ssm", "ValidNextStepList"),
         374  +
    ::aws_smithy_schema::ShapeType::String,
         375  +
    "member",
         376  +
    0,
         377  +
);
         378  +
static STEPEXECUTION_MEMBER_VALID_NEXT_STEPS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         379  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$ValidNextSteps", "com.amazonaws.ssm", "StepExecution"),
         380  +
    ::aws_smithy_schema::ShapeType::List,
         381  +
    "ValidNextSteps",
         382  +
    20,
         383  +
)
         384  +
.with_list_member(&STEPEXECUTION_MEMBER_VALID_NEXT_STEPS_MEMBER);
         385  +
static STEPEXECUTION_MEMBER_TARGETS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         386  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Targets$member", "com.amazonaws.ssm", "Targets"),
         387  +
    ::aws_smithy_schema::ShapeType::Structure,
         388  +
    "member",
         389  +
    0,
         390  +
);
         391  +
static STEPEXECUTION_MEMBER_TARGETS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         392  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$Targets", "com.amazonaws.ssm", "StepExecution"),
         393  +
    ::aws_smithy_schema::ShapeType::List,
         394  +
    "Targets",
         395  +
    21,
         396  +
)
         397  +
.with_list_member(&STEPEXECUTION_MEMBER_TARGETS_MEMBER);
         398  +
static STEPEXECUTION_MEMBER_TARGET_LOCATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         399  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$TargetLocation", "com.amazonaws.ssm", "StepExecution"),
         400  +
    ::aws_smithy_schema::ShapeType::Structure,
         401  +
    "TargetLocation",
         402  +
    22,
         403  +
);
         404  +
static STEPEXECUTION_MEMBER_TRIGGERED_ALARMS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         405  +
    ::aws_smithy_schema::ShapeId::from_parts(
         406  +
        "com.amazonaws.ssm#AlarmStateInformationList$member",
         407  +
        "com.amazonaws.ssm",
         408  +
        "AlarmStateInformationList",
         409  +
    ),
         410  +
    ::aws_smithy_schema::ShapeType::Structure,
         411  +
    "member",
         412  +
    0,
         413  +
);
         414  +
static STEPEXECUTION_MEMBER_TRIGGERED_ALARMS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         415  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$TriggeredAlarms", "com.amazonaws.ssm", "StepExecution"),
         416  +
    ::aws_smithy_schema::ShapeType::List,
         417  +
    "TriggeredAlarms",
         418  +
    23,
         419  +
)
         420  +
.with_list_member(&STEPEXECUTION_MEMBER_TRIGGERED_ALARMS_MEMBER);
         421  +
static STEPEXECUTION_MEMBER_PARENT_STEP_DETAILS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         422  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution$ParentStepDetails", "com.amazonaws.ssm", "StepExecution"),
         423  +
    ::aws_smithy_schema::ShapeType::Structure,
         424  +
    "ParentStepDetails",
         425  +
    24,
         426  +
);
         427  +
static STEPEXECUTION_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         428  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#StepExecution", "com.amazonaws.ssm", "StepExecution"),
         429  +
    ::aws_smithy_schema::ShapeType::Structure,
         430  +
    &[
         431  +
        &STEPEXECUTION_MEMBER_STEP_NAME,
         432  +
        &STEPEXECUTION_MEMBER_ACTION,
         433  +
        &STEPEXECUTION_MEMBER_TIMEOUT_SECONDS,
         434  +
        &STEPEXECUTION_MEMBER_ON_FAILURE,
         435  +
        &STEPEXECUTION_MEMBER_MAX_ATTEMPTS,
         436  +
        &STEPEXECUTION_MEMBER_EXECUTION_START_TIME,
         437  +
        &STEPEXECUTION_MEMBER_EXECUTION_END_TIME,
         438  +
        &STEPEXECUTION_MEMBER_STEP_STATUS,
         439  +
        &STEPEXECUTION_MEMBER_RESPONSE_CODE,
         440  +
        &STEPEXECUTION_MEMBER_INPUTS,
         441  +
        &STEPEXECUTION_MEMBER_OUTPUTS,
         442  +
        &STEPEXECUTION_MEMBER_RESPONSE,
         443  +
        &STEPEXECUTION_MEMBER_FAILURE_MESSAGE,
         444  +
        &STEPEXECUTION_MEMBER_WARNING_MESSAGE,
         445  +
        &STEPEXECUTION_MEMBER_FAILURE_DETAILS,
         446  +
        &STEPEXECUTION_MEMBER_STEP_EXECUTION_ID,
         447  +
        &STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS,
         448  +
        &STEPEXECUTION_MEMBER_IS_END,
         449  +
        &STEPEXECUTION_MEMBER_NEXT_STEP,
         450  +
        &STEPEXECUTION_MEMBER_IS_CRITICAL,
         451  +
        &STEPEXECUTION_MEMBER_VALID_NEXT_STEPS,
         452  +
        &STEPEXECUTION_MEMBER_TARGETS,
         453  +
        &STEPEXECUTION_MEMBER_TARGET_LOCATION,
         454  +
        &STEPEXECUTION_MEMBER_TRIGGERED_ALARMS,
         455  +
        &STEPEXECUTION_MEMBER_PARENT_STEP_DETAILS,
         456  +
    ],
         457  +
);
         458  +
impl StepExecution {
         459  +
    /// The schema for this shape.
         460  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &STEPEXECUTION_SCHEMA;
         461  +
}
         462  +
impl ::aws_smithy_schema::serde::SerializableStruct for StepExecution {
         463  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         464  +
    fn serialize_members(
         465  +
        &self,
         466  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         467  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         468  +
        if let Some(ref val) = self.step_name {
         469  +
            ser.write_string(&STEPEXECUTION_MEMBER_STEP_NAME, val)?;
         470  +
        }
         471  +
        if let Some(ref val) = self.action {
         472  +
            ser.write_string(&STEPEXECUTION_MEMBER_ACTION, val)?;
         473  +
        }
         474  +
        if let Some(ref val) = self.timeout_seconds {
         475  +
            ser.write_long(&STEPEXECUTION_MEMBER_TIMEOUT_SECONDS, *val)?;
         476  +
        }
         477  +
        if let Some(ref val) = self.on_failure {
         478  +
            ser.write_string(&STEPEXECUTION_MEMBER_ON_FAILURE, val)?;
         479  +
        }
         480  +
        if let Some(ref val) = self.max_attempts {
         481  +
            ser.write_integer(&STEPEXECUTION_MEMBER_MAX_ATTEMPTS, *val)?;
         482  +
        }
         483  +
        if let Some(ref val) = self.execution_start_time {
         484  +
            ser.write_timestamp(&STEPEXECUTION_MEMBER_EXECUTION_START_TIME, val)?;
         485  +
        }
         486  +
        if let Some(ref val) = self.execution_end_time {
         487  +
            ser.write_timestamp(&STEPEXECUTION_MEMBER_EXECUTION_END_TIME, val)?;
         488  +
        }
         489  +
        if let Some(ref val) = self.step_status {
         490  +
            ser.write_string(&STEPEXECUTION_MEMBER_STEP_STATUS, val.as_str())?;
         491  +
        }
         492  +
        if let Some(ref val) = self.response_code {
         493  +
            ser.write_string(&STEPEXECUTION_MEMBER_RESPONSE_CODE, val)?;
         494  +
        }
         495  +
        if let Some(ref val) = self.inputs {
         496  +
            ser.write_map(
         497  +
                &STEPEXECUTION_MEMBER_INPUTS,
         498  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         499  +
                    for (key, value) in val {
         500  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         501  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
         502  +
                    }
         503  +
                    Ok(())
         504  +
                },
         505  +
            )?;
         506  +
        }
         507  +
        if let Some(ref val) = self.outputs {
         508  +
            ser.write_map(
         509  +
                &STEPEXECUTION_MEMBER_OUTPUTS,
         510  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         511  +
                    for (key, value) in val {
         512  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         513  +
         514  +
                        ser.write_list(
         515  +
                            &STEPEXECUTION_MEMBER_OUTPUTS_VALUE,
         516  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         517  +
                                for item in value {
         518  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         519  +
                                }
         520  +
                                Ok(())
         521  +
                            },
         522  +
                        )?;
         523  +
                    }
         524  +
                    Ok(())
         525  +
                },
         526  +
            )?;
         527  +
        }
         528  +
        if let Some(ref val) = self.response {
         529  +
            ser.write_string(&STEPEXECUTION_MEMBER_RESPONSE, val)?;
         530  +
        }
         531  +
        if let Some(ref val) = self.failure_message {
         532  +
            ser.write_string(&STEPEXECUTION_MEMBER_FAILURE_MESSAGE, val)?;
         533  +
        }
         534  +
        if let Some(ref val) = self.warning_message {
         535  +
            ser.write_string(&STEPEXECUTION_MEMBER_WARNING_MESSAGE, val)?;
         536  +
        }
         537  +
        if let Some(ref val) = self.failure_details {
         538  +
            ser.write_struct(&STEPEXECUTION_MEMBER_FAILURE_DETAILS, val)?;
         539  +
        }
         540  +
        if let Some(ref val) = self.step_execution_id {
         541  +
            ser.write_string(&STEPEXECUTION_MEMBER_STEP_EXECUTION_ID, val)?;
         542  +
        }
         543  +
        if let Some(ref val) = self.overridden_parameters {
         544  +
            ser.write_map(
         545  +
                &STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS,
         546  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         547  +
                    for (key, value) in val {
         548  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         549  +
         550  +
                        ser.write_list(
         551  +
                            &STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_VALUE,
         552  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         553  +
                                for item in value {
         554  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         555  +
                                }
         556  +
                                Ok(())
         557  +
                            },
         558  +
                        )?;
         559  +
                    }
         560  +
                    Ok(())
         561  +
                },
         562  +
            )?;
         563  +
        }
         564  +
        if let Some(ref val) = self.is_end {
         565  +
            ser.write_boolean(&STEPEXECUTION_MEMBER_IS_END, *val)?;
         566  +
        }
         567  +
        if let Some(ref val) = self.next_step {
         568  +
            ser.write_string(&STEPEXECUTION_MEMBER_NEXT_STEP, val)?;
         569  +
        }
         570  +
        if let Some(ref val) = self.is_critical {
         571  +
            ser.write_boolean(&STEPEXECUTION_MEMBER_IS_CRITICAL, *val)?;
         572  +
        }
         573  +
        if let Some(ref val) = self.valid_next_steps {
         574  +
            ser.write_list(
         575  +
                &STEPEXECUTION_MEMBER_VALID_NEXT_STEPS,
         576  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         577  +
                    for item in val {
         578  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         579  +
                    }
         580  +
                    Ok(())
         581  +
                },
         582  +
            )?;
         583  +
        }
         584  +
        if let Some(ref val) = self.targets {
         585  +
            ser.write_list(
         586  +
                &STEPEXECUTION_MEMBER_TARGETS,
         587  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         588  +
                    for item in val {
         589  +
                        ser.write_struct(crate::types::Target::SCHEMA, item)?;
         590  +
                    }
         591  +
                    Ok(())
         592  +
                },
         593  +
            )?;
         594  +
        }
         595  +
        if let Some(ref val) = self.target_location {
         596  +
            ser.write_struct(&STEPEXECUTION_MEMBER_TARGET_LOCATION, val)?;
         597  +
        }
         598  +
        if let Some(ref val) = self.triggered_alarms {
         599  +
            ser.write_list(
         600  +
                &STEPEXECUTION_MEMBER_TRIGGERED_ALARMS,
         601  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         602  +
                    for item in val {
         603  +
                        ser.write_struct(crate::types::AlarmStateInformation::SCHEMA, item)?;
         604  +
                    }
         605  +
                    Ok(())
         606  +
                },
         607  +
            )?;
         608  +
        }
         609  +
        if let Some(ref val) = self.parent_step_details {
         610  +
            ser.write_struct(&STEPEXECUTION_MEMBER_PARENT_STEP_DETAILS, val)?;
         611  +
        }
         612  +
        Ok(())
         613  +
    }
         614  +
}
         615  +
impl StepExecution {
         616  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         617  +
    pub fn deserialize(
         618  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         619  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         620  +
        #[allow(unused_variables, unused_mut)]
         621  +
        let mut builder = Self::builder();
         622  +
        #[allow(
         623  +
            unused_variables,
         624  +
            unreachable_code,
         625  +
            clippy::single_match,
         626  +
            clippy::match_single_binding,
         627  +
            clippy::diverging_sub_expression
         628  +
        )]
         629  +
        deserializer.read_struct(&STEPEXECUTION_SCHEMA, &mut |member, deser| {
         630  +
            match member.member_index() {
         631  +
                Some(0) => {
         632  +
                    if deser.is_null() {
         633  +
                        deser.read_null()?;
         634  +
                    } else {
         635  +
                        builder.step_name = Some(deser.read_string(member)?);
         636  +
                    }
         637  +
                }
         638  +
                Some(1) => {
         639  +
                    if deser.is_null() {
         640  +
                        deser.read_null()?;
         641  +
                    } else {
         642  +
                        builder.action = Some(deser.read_string(member)?);
         643  +
                    }
         644  +
                }
         645  +
                Some(2) => {
         646  +
                    if deser.is_null() {
         647  +
                        deser.read_null()?;
         648  +
                    } else {
         649  +
                        builder.timeout_seconds = Some(deser.read_long(member)?);
         650  +
                    }
         651  +
                }
         652  +
                Some(3) => {
         653  +
                    if deser.is_null() {
         654  +
                        deser.read_null()?;
         655  +
                    } else {
         656  +
                        builder.on_failure = Some(deser.read_string(member)?);
         657  +
                    }
         658  +
                }
         659  +
                Some(4) => {
         660  +
                    if deser.is_null() {
         661  +
                        deser.read_null()?;
         662  +
                    } else {
         663  +
                        builder.max_attempts = Some(deser.read_integer(member)?);
         664  +
                    }
         665  +
                }
         666  +
                Some(5) => {
         667  +
                    if deser.is_null() {
         668  +
                        deser.read_null()?;
         669  +
                    } else {
         670  +
                        builder.execution_start_time = Some(deser.read_timestamp(member)?);
         671  +
                    }
         672  +
                }
         673  +
                Some(6) => {
         674  +
                    if deser.is_null() {
         675  +
                        deser.read_null()?;
         676  +
                    } else {
         677  +
                        builder.execution_end_time = Some(deser.read_timestamp(member)?);
         678  +
                    }
         679  +
                }
         680  +
                Some(7) => {
         681  +
                    if deser.is_null() {
         682  +
                        deser.read_null()?;
         683  +
                    } else {
         684  +
                        builder.step_status = Some(crate::types::AutomationExecutionStatus::from(deser.read_string(member)?.as_str()));
         685  +
                    }
         686  +
                }
         687  +
                Some(8) => {
         688  +
                    if deser.is_null() {
         689  +
                        deser.read_null()?;
         690  +
                    } else {
         691  +
                        builder.response_code = Some(deser.read_string(member)?);
         692  +
                    }
         693  +
                }
         694  +
                Some(9) => {
         695  +
                    if deser.is_null() {
         696  +
                        deser.read_null()?;
         697  +
                    } else {
         698  +
                        builder.inputs = Some(deser.read_string_string_map(member)?);
         699  +
                    }
         700  +
                }
         701  +
                Some(10) => {
         702  +
                    if deser.is_null() {
         703  +
                        deser.read_null()?;
         704  +
                    } else {
         705  +
                        builder.outputs = Some({
         706  +
                            let mut container = std::collections::HashMap::new();
         707  +
                            deser.read_map(member, &mut |key, deser| {
         708  +
                                container.insert(key, {
         709  +
                                    let mut list = Vec::new();
         710  +
                                    deser.read_list(&STEPEXECUTION_MEMBER_OUTPUTS_VALUE, &mut |deser| {
         711  +
                                        list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
         712  +
                                        Ok(())
         713  +
                                    })?;
         714  +
                                    list
         715  +
                                });
         716  +
                                Ok(())
         717  +
                            })?;
         718  +
                            container
         719  +
                        });
         720  +
                    }
         721  +
                }
         722  +
                Some(11) => {
         723  +
                    if deser.is_null() {
         724  +
                        deser.read_null()?;
         725  +
                    } else {
         726  +
                        builder.response = Some(deser.read_string(member)?);
         727  +
                    }
         728  +
                }
         729  +
                Some(12) => {
         730  +
                    if deser.is_null() {
         731  +
                        deser.read_null()?;
         732  +
                    } else {
         733  +
                        builder.failure_message = Some(deser.read_string(member)?);
         734  +
                    }
         735  +
                }
         736  +
                Some(13) => {
         737  +
                    if deser.is_null() {
         738  +
                        deser.read_null()?;
         739  +
                    } else {
         740  +
                        builder.warning_message = Some(deser.read_string(member)?);
         741  +
                    }
         742  +
                }
         743  +
                Some(14) => {
         744  +
                    if deser.is_null() {
         745  +
                        deser.read_null()?;
         746  +
                    } else {
         747  +
                        builder.failure_details = Some(crate::types::FailureDetails::deserialize(deser)?);
         748  +
                    }
         749  +
                }
         750  +
                Some(15) => {
         751  +
                    if deser.is_null() {
         752  +
                        deser.read_null()?;
         753  +
                    } else {
         754  +
                        builder.step_execution_id = Some(deser.read_string(member)?);
         755  +
                    }
         756  +
                }
         757  +
                Some(16) => {
         758  +
                    if deser.is_null() {
         759  +
                        deser.read_null()?;
         760  +
                    } else {
         761  +
                        builder.overridden_parameters = Some({
         762  +
                            let mut container = std::collections::HashMap::new();
         763  +
                            deser.read_map(member, &mut |key, deser| {
         764  +
                                container.insert(key, {
         765  +
                                    let mut list = Vec::new();
         766  +
                                    deser.read_list(&STEPEXECUTION_MEMBER_OVERRIDDEN_PARAMETERS_VALUE, &mut |deser| {
         767  +
                                        list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
         768  +
                                        Ok(())
         769  +
                                    })?;
         770  +
                                    list
         771  +
                                });
         772  +
                                Ok(())
         773  +
                            })?;
         774  +
                            container
         775  +
                        });
         776  +
                    }
         777  +
                }
         778  +
                Some(17) => {
         779  +
                    if deser.is_null() {
         780  +
                        deser.read_null()?;
         781  +
                    } else {
         782  +
                        builder.is_end = Some(deser.read_boolean(member)?);
         783  +
                    }
         784  +
                }
         785  +
                Some(18) => {
         786  +
                    if deser.is_null() {
         787  +
                        deser.read_null()?;
         788  +
                    } else {
         789  +
                        builder.next_step = Some(deser.read_string(member)?);
         790  +
                    }
         791  +
                }
         792  +
                Some(19) => {
         793  +
                    if deser.is_null() {
         794  +
                        deser.read_null()?;
         795  +
                    } else {
         796  +
                        builder.is_critical = Some(deser.read_boolean(member)?);
         797  +
                    }
         798  +
                }
         799  +
                Some(20) => {
         800  +
                    if deser.is_null() {
         801  +
                        deser.read_null()?;
         802  +
                    } else {
         803  +
                        builder.valid_next_steps = Some(deser.read_string_list(member)?);
         804  +
                    }
         805  +
                }
         806  +
                Some(21) => {
         807  +
                    if deser.is_null() {
         808  +
                        deser.read_null()?;
         809  +
                    } else {
         810  +
                        builder.targets = Some({
         811  +
                            let mut container = Vec::new();
         812  +
                            deser.read_list(member, &mut |deser| {
         813  +
                                container.push(crate::types::Target::deserialize(deser)?);
         814  +
                                Ok(())
         815  +
                            })?;
         816  +
                            container
         817  +
                        });
         818  +
                    }
         819  +
                }
         820  +
                Some(22) => {
         821  +
                    if deser.is_null() {
         822  +
                        deser.read_null()?;
         823  +
                    } else {
         824  +
                        builder.target_location = Some(crate::types::TargetLocation::deserialize(deser)?);
         825  +
                    }
         826  +
                }
         827  +
                Some(23) => {
         828  +
                    if deser.is_null() {
         829  +
                        deser.read_null()?;
         830  +
                    } else {
         831  +
                        builder.triggered_alarms = Some({
         832  +
                            let mut container = Vec::new();
         833  +
                            deser.read_list(member, &mut |deser| {
         834  +
                                container.push(crate::types::AlarmStateInformation::deserialize(deser)?);
         835  +
                                Ok(())
         836  +
                            })?;
         837  +
                            container
         838  +
                        });
         839  +
                    }
         840  +
                }
         841  +
                Some(24) => {
         842  +
                    if deser.is_null() {
         843  +
                        deser.read_null()?;
         844  +
                    } else {
         845  +
                        builder.parent_step_details = Some(crate::types::ParentStepDetails::deserialize(deser)?);
         846  +
                    }
         847  +
                }
         848  +
                _ => {}
         849  +
            }
         850  +
            Ok(())
         851  +
        })?;
         852  +
        Ok(builder.build())
         853  +
    }
         854  +
}
         855  +
impl StepExecution {
         856  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         857  +
    pub fn deserialize_with_response(
         858  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         859  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         860  +
        _status: u16,
         861  +
        _body: &[u8],
         862  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         863  +
        Self::deserialize(deserializer)
         864  +
    }
         865  +
}
         866  +
impl StepExecution {
         867  +
    /// Creates a new builder-style object to manufacture [`StepExecution`](crate::types::StepExecution).
         868  +
    pub fn builder() -> crate::types::builders::StepExecutionBuilder {
         869  +
        crate::types::builders::StepExecutionBuilder::default()
         870  +
    }
         871  +
}
         872  +
         873  +
/// A builder for [`StepExecution`](crate::types::StepExecution).
         874  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         875  +
#[non_exhaustive]
         876  +
pub struct StepExecutionBuilder {
         877  +
    pub(crate) step_name: ::std::option::Option<::std::string::String>,
         878  +
    pub(crate) action: ::std::option::Option<::std::string::String>,
         879  +
    pub(crate) timeout_seconds: ::std::option::Option<i64>,
         880  +
    pub(crate) on_failure: ::std::option::Option<::std::string::String>,
         881  +
    pub(crate) max_attempts: ::std::option::Option<i32>,
         882  +
    pub(crate) execution_start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
         883  +
    pub(crate) execution_end_time: ::std::option::Option<::aws_smithy_types::DateTime>,
         884  +
    pub(crate) step_status: ::std::option::Option<crate::types::AutomationExecutionStatus>,
         885  +
    pub(crate) response_code: ::std::option::Option<::std::string::String>,
         886  +
    pub(crate) inputs: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
         887  +
    pub(crate) outputs: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
         888  +
    pub(crate) response: ::std::option::Option<::std::string::String>,
         889  +
    pub(crate) failure_message: ::std::option::Option<::std::string::String>,
         890  +
    pub(crate) warning_message: ::std::option::Option<::std::string::String>,
         891  +
    pub(crate) failure_details: ::std::option::Option<crate::types::FailureDetails>,
         892  +
    pub(crate) step_execution_id: ::std::option::Option<::std::string::String>,
         893  +
    pub(crate) overridden_parameters:
         894  +
        ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
         895  +
    pub(crate) is_end: ::std::option::Option<bool>,
         896  +
    pub(crate) next_step: ::std::option::Option<::std::string::String>,
         897  +
    pub(crate) is_critical: ::std::option::Option<bool>,
         898  +
    pub(crate) valid_next_steps: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         899  +
    pub(crate) targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
         900  +
    pub(crate) target_location: ::std::option::Option<crate::types::TargetLocation>,
         901  +
    pub(crate) triggered_alarms: ::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>>,
         902  +
    pub(crate) parent_step_details: ::std::option::Option<crate::types::ParentStepDetails>,
         903  +
}
         904  +
impl StepExecutionBuilder {
         905  +
    /// <p>The name of this execution step.</p>
         906  +
    pub fn step_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         907  +
        self.step_name = ::std::option::Option::Some(input.into());
         908  +
        self
         909  +
    }
         910  +
    /// <p>The name of this execution step.</p>
         911  +
    pub fn set_step_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         912  +
        self.step_name = input;
         913  +
        self
         914  +
    }
         915  +
    /// <p>The name of this execution step.</p>
         916  +
    pub fn get_step_name(&self) -> &::std::option::Option<::std::string::String> {
         917  +
        &self.step_name
         918  +
    }
         919  +
    /// <p>The action this step performs. The action determines the behavior of the step.</p>
         920  +
    pub fn action(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         921  +
        self.action = ::std::option::Option::Some(input.into());
         922  +
        self
         923  +
    }
         924  +
    /// <p>The action this step performs. The action determines the behavior of the step.</p>
         925  +
    pub fn set_action(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         926  +
        self.action = input;
         927  +
        self
         928  +
    }
         929  +
    /// <p>The action this step performs. The action determines the behavior of the step.</p>
         930  +
    pub fn get_action(&self) -> &::std::option::Option<::std::string::String> {
         931  +
        &self.action
         932  +
    }
         933  +
    /// <p>The timeout seconds of the step.</p>
         934  +
    pub fn timeout_seconds(mut self, input: i64) -> Self {
         935  +
        self.timeout_seconds = ::std::option::Option::Some(input);
         936  +
        self
         937  +
    }
         938  +
    /// <p>The timeout seconds of the step.</p>
         939  +
    pub fn set_timeout_seconds(mut self, input: ::std::option::Option<i64>) -> Self {
         940  +
        self.timeout_seconds = input;
         941  +
        self
         942  +
    }
         943  +
    /// <p>The timeout seconds of the step.</p>
         944  +
    pub fn get_timeout_seconds(&self) -> &::std::option::Option<i64> {
         945  +
        &self.timeout_seconds
         946  +
    }
         947  +
    /// <p>The action to take if the step fails. The default value is <code>Abort</code>.</p>
         948  +
    pub fn on_failure(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         949  +
        self.on_failure = ::std::option::Option::Some(input.into());
         950  +
        self
         951  +
    }
         952  +
    /// <p>The action to take if the step fails. The default value is <code>Abort</code>.</p>
         953  +
    pub fn set_on_failure(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         954  +
        self.on_failure = input;
         955  +
        self
         956  +
    }
         957  +
    /// <p>The action to take if the step fails. The default value is <code>Abort</code>.</p>
         958  +
    pub fn get_on_failure(&self) -> &::std::option::Option<::std::string::String> {
         959  +
        &self.on_failure
         960  +
    }
         961  +
    /// <p>The maximum number of tries to run the action of the step. The default value is <code>1</code>.</p>
         962  +
    pub fn max_attempts(mut self, input: i32) -> Self {
         963  +
        self.max_attempts = ::std::option::Option::Some(input);
         964  +
        self
         965  +
    }
         966  +
    /// <p>The maximum number of tries to run the action of the step. The default value is <code>1</code>.</p>
         967  +
    pub fn set_max_attempts(mut self, input: ::std::option::Option<i32>) -> Self {
         968  +
        self.max_attempts = input;
         969  +
        self
         970  +
    }
         971  +
    /// <p>The maximum number of tries to run the action of the step. The default value is <code>1</code>.</p>
         972  +
    pub fn get_max_attempts(&self) -> &::std::option::Option<i32> {
         973  +
        &self.max_attempts
         974  +
    }
         975  +
    /// <p>If a step has begun execution, this contains the time the step started. If the step is in Pending status, this field isn't populated.</p>
         976  +
    pub fn execution_start_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         977  +
        self.execution_start_time = ::std::option::Option::Some(input);
         978  +
        self
         979  +
    }
         980  +
    /// <p>If a step has begun execution, this contains the time the step started. If the step is in Pending status, this field isn't populated.</p>
         981  +
    pub fn set_execution_start_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         982  +
        self.execution_start_time = input;
         983  +
        self
         984  +
    }
         985  +
    /// <p>If a step has begun execution, this contains the time the step started. If the step is in Pending status, this field isn't populated.</p>
         986  +
    pub fn get_execution_start_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         987  +
        &self.execution_start_time
         988  +
    }
         989  +
    /// <p>If a step has finished execution, this contains the time the execution ended. If the step hasn't yet concluded, this field isn't populated.</p>
         990  +
    pub fn execution_end_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         991  +
        self.execution_end_time = ::std::option::Option::Some(input);
         992  +
        self
         993  +
    }
         994  +
    /// <p>If a step has finished execution, this contains the time the execution ended. If the step hasn't yet concluded, this field isn't populated.</p>
         995  +
    pub fn set_execution_end_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         996  +
        self.execution_end_time = input;
         997  +
        self
         998  +
    }
         999  +
    /// <p>If a step has finished execution, this contains the time the execution ended. If the step hasn't yet concluded, this field isn't populated.</p>
        1000  +
    pub fn get_execution_end_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
        1001  +
        &self.execution_end_time
        1002  +
    }
        1003  +
    /// <p>The execution status for this step.</p>
        1004  +
    pub fn step_status(mut self, input: crate::types::AutomationExecutionStatus) -> Self {
        1005  +
        self.step_status = ::std::option::Option::Some(input);
        1006  +
        self
        1007  +
    }
        1008  +
    /// <p>The execution status for this step.</p>
        1009  +
    pub fn set_step_status(mut self, input: ::std::option::Option<crate::types::AutomationExecutionStatus>) -> Self {
        1010  +
        self.step_status = input;
        1011  +
        self
        1012  +
    }
        1013  +
    /// <p>The execution status for this step.</p>
        1014  +
    pub fn get_step_status(&self) -> &::std::option::Option<crate::types::AutomationExecutionStatus> {
        1015  +
        &self.step_status
        1016  +
    }
        1017  +
    /// <p>The response code returned by the execution of the step.</p>
        1018  +
    pub fn response_code(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1019  +
        self.response_code = ::std::option::Option::Some(input.into());
        1020  +
        self
        1021  +
    }
        1022  +
    /// <p>The response code returned by the execution of the step.</p>
        1023  +
    pub fn set_response_code(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1024  +
        self.response_code = input;
        1025  +
        self
        1026  +
    }
        1027  +
    /// <p>The response code returned by the execution of the step.</p>
        1028  +
    pub fn get_response_code(&self) -> &::std::option::Option<::std::string::String> {
        1029  +
        &self.response_code
        1030  +
    }
        1031  +
    /// Adds a key-value pair to `inputs`.
        1032  +
    ///
        1033  +
    /// To override the contents of this collection use [`set_inputs`](Self::set_inputs).
        1034  +
    ///
        1035  +
    /// <p>Fully-resolved values passed into the step before execution.</p>
        1036  +
    pub fn inputs(mut self, k: impl ::std::convert::Into<::std::string::String>, v: impl ::std::convert::Into<::std::string::String>) -> Self {
        1037  +
        let mut hash_map = self.inputs.unwrap_or_default();
        1038  +
        hash_map.insert(k.into(), v.into());
        1039  +
        self.inputs = ::std::option::Option::Some(hash_map);
        1040  +
        self
        1041  +
    }
        1042  +
    /// <p>Fully-resolved values passed into the step before execution.</p>
        1043  +
    pub fn set_inputs(mut self, input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>) -> Self {
        1044  +
        self.inputs = input;
        1045  +
        self
        1046  +
    }
        1047  +
    /// <p>Fully-resolved values passed into the step before execution.</p>
        1048  +
    pub fn get_inputs(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>> {
        1049  +
        &self.inputs
        1050  +
    }
        1051  +
    /// Adds a key-value pair to `outputs`.
        1052  +
    ///
        1053  +
    /// To override the contents of this collection use [`set_outputs`](Self::set_outputs).
        1054  +
    ///
        1055  +
    /// <p>Returned values from the execution of the step.</p>
        1056  +
    pub fn outputs(mut self, k: impl ::std::convert::Into<::std::string::String>, v: ::std::vec::Vec<::std::string::String>) -> Self {
        1057  +
        let mut hash_map = self.outputs.unwrap_or_default();
        1058  +
        hash_map.insert(k.into(), v);
        1059  +
        self.outputs = ::std::option::Option::Some(hash_map);
        1060  +
        self
        1061  +
    }
        1062  +
    /// <p>Returned values from the execution of the step.</p>
        1063  +
    pub fn set_outputs(
        1064  +
        mut self,
        1065  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
        1066  +
    ) -> Self {
        1067  +
        self.outputs = input;
        1068  +
        self
        1069  +
    }
        1070  +
    /// <p>Returned values from the execution of the step.</p>
        1071  +
    pub fn get_outputs(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
        1072  +
        &self.outputs
        1073  +
    }
        1074  +
    /// <p>A message associated with the response code for an execution.</p>
        1075  +
    pub fn response(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1076  +
        self.response = ::std::option::Option::Some(input.into());
        1077  +
        self
        1078  +
    }
        1079  +
    /// <p>A message associated with the response code for an execution.</p>
        1080  +
    pub fn set_response(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1081  +
        self.response = input;
        1082  +
        self
        1083  +
    }
        1084  +
    /// <p>A message associated with the response code for an execution.</p>
        1085  +
    pub fn get_response(&self) -> &::std::option::Option<::std::string::String> {
        1086  +
        &self.response
        1087  +
    }
        1088  +
    /// <p>If a step failed, this message explains why the execution failed.</p>
        1089  +
    pub fn failure_message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1090  +
        self.failure_message = ::std::option::Option::Some(input.into());
        1091  +
        self
        1092  +
    }
        1093  +
    /// <p>If a step failed, this message explains why the execution failed.</p>
        1094  +
    pub fn set_failure_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1095  +
        self.failure_message = input;
        1096  +
        self
        1097  +
    }
        1098  +
    /// <p>If a step failed, this message explains why the execution failed.</p>
        1099  +
    pub fn get_failure_message(&self) -> &::std::option::Option<::std::string::String> {
        1100  +
        &self.failure_message
        1101  +
    }
        1102  +
    /// <p>A message that describes a non-critical issue that occurred during the step execution. Present only if the step status includes a warning.</p>
        1103  +
    pub fn warning_message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1104  +
        self.warning_message = ::std::option::Option::Some(input.into());
        1105  +
        self
        1106  +
    }
        1107  +
    /// <p>A message that describes a non-critical issue that occurred during the step execution. Present only if the step status includes a warning.</p>
        1108  +
    pub fn set_warning_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1109  +
        self.warning_message = input;
        1110  +
        self
        1111  +
    }
        1112  +
    /// <p>A message that describes a non-critical issue that occurred during the step execution. Present only if the step status includes a warning.</p>
        1113  +
    pub fn get_warning_message(&self) -> &::std::option::Option<::std::string::String> {
        1114  +
        &self.warning_message
        1115  +
    }
        1116  +
    /// <p>Information about the Automation failure.</p>
        1117  +
    pub fn failure_details(mut self, input: crate::types::FailureDetails) -> Self {
        1118  +
        self.failure_details = ::std::option::Option::Some(input);
        1119  +
        self
        1120  +
    }
        1121  +
    /// <p>Information about the Automation failure.</p>
        1122  +
    pub fn set_failure_details(mut self, input: ::std::option::Option<crate::types::FailureDetails>) -> Self {
        1123  +
        self.failure_details = input;
        1124  +
        self
        1125  +
    }
        1126  +
    /// <p>Information about the Automation failure.</p>
        1127  +
    pub fn get_failure_details(&self) -> &::std::option::Option<crate::types::FailureDetails> {
        1128  +
        &self.failure_details
        1129  +
    }
        1130  +
    /// <p>The unique ID of a step execution.</p>
        1131  +
    pub fn step_execution_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1132  +
        self.step_execution_id = ::std::option::Option::Some(input.into());
        1133  +
        self
        1134  +
    }
        1135  +
    /// <p>The unique ID of a step execution.</p>
        1136  +
    pub fn set_step_execution_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1137  +
        self.step_execution_id = input;
        1138  +
        self
        1139  +
    }
        1140  +
    /// <p>The unique ID of a step execution.</p>
        1141  +
    pub fn get_step_execution_id(&self) -> &::std::option::Option<::std::string::String> {
        1142  +
        &self.step_execution_id
        1143  +
    }
        1144  +
    /// Adds a key-value pair to `overridden_parameters`.
        1145  +
    ///
        1146  +
    /// To override the contents of this collection use [`set_overridden_parameters`](Self::set_overridden_parameters).
        1147  +
    ///
        1148  +
    /// <p>A user-specified list of parameters to override when running a step.</p>
        1149  +
    pub fn overridden_parameters(mut self, k: impl ::std::convert::Into<::std::string::String>, v: ::std::vec::Vec<::std::string::String>) -> Self {
        1150  +
        let mut hash_map = self.overridden_parameters.unwrap_or_default();
        1151  +
        hash_map.insert(k.into(), v);
        1152  +
        self.overridden_parameters = ::std::option::Option::Some(hash_map);
        1153  +
        self
        1154  +
    }
        1155  +
    /// <p>A user-specified list of parameters to override when running a step.</p>
        1156  +
    pub fn set_overridden_parameters(
        1157  +
        mut self,
        1158  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
        1159  +
    ) -> Self {
        1160  +
        self.overridden_parameters = input;
        1161  +
        self
        1162  +
    }
        1163  +
    /// <p>A user-specified list of parameters to override when running a step.</p>
        1164  +
    pub fn get_overridden_parameters(
        1165  +
        &self,
        1166  +
    ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
        1167  +
        &self.overridden_parameters
        1168  +
    }
        1169  +
    /// <p>The flag which can be used to end automation no matter whether the step succeeds or fails.</p>
        1170  +
    pub fn is_end(mut self, input: bool) -> Self {
        1171  +
        self.is_end = ::std::option::Option::Some(input);
        1172  +
        self
        1173  +
    }
        1174  +
    /// <p>The flag which can be used to end automation no matter whether the step succeeds or fails.</p>
        1175  +
    pub fn set_is_end(mut self, input: ::std::option::Option<bool>) -> Self {
        1176  +
        self.is_end = input;
        1177  +
        self
        1178  +
    }
        1179  +
    /// <p>The flag which can be used to end automation no matter whether the step succeeds or fails.</p>
        1180  +
    pub fn get_is_end(&self) -> &::std::option::Option<bool> {
        1181  +
        &self.is_end
        1182  +
    }
        1183  +
    /// <p>The next step after the step succeeds.</p>
        1184  +
    pub fn next_step(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1185  +
        self.next_step = ::std::option::Option::Some(input.into());
        1186  +
        self
        1187  +
    }
        1188  +
    /// <p>The next step after the step succeeds.</p>
        1189  +
    pub fn set_next_step(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1190  +
        self.next_step = input;
        1191  +
        self
        1192  +
    }
        1193  +
    /// <p>The next step after the step succeeds.</p>
        1194  +
    pub fn get_next_step(&self) -> &::std::option::Option<::std::string::String> {
        1195  +
        &self.next_step
        1196  +
    }
        1197  +
    /// <p>The flag which can be used to help decide whether the failure of current step leads to the Automation failure.</p>
        1198  +
    pub fn is_critical(mut self, input: bool) -> Self {
        1199  +
        self.is_critical = ::std::option::Option::Some(input);
        1200  +
        self
        1201  +
    }
        1202  +
    /// <p>The flag which can be used to help decide whether the failure of current step leads to the Automation failure.</p>
        1203  +
    pub fn set_is_critical(mut self, input: ::std::option::Option<bool>) -> Self {
        1204  +
        self.is_critical = input;
        1205  +
        self
        1206  +
    }
        1207  +
    /// <p>The flag which can be used to help decide whether the failure of current step leads to the Automation failure.</p>
        1208  +
    pub fn get_is_critical(&self) -> &::std::option::Option<bool> {
        1209  +
        &self.is_critical
        1210  +
    }
        1211  +
    /// Appends an item to `valid_next_steps`.
        1212  +
    ///
        1213  +
    /// To override the contents of this collection use [`set_valid_next_steps`](Self::set_valid_next_steps).
        1214  +
    ///
        1215  +
    /// <p>Strategies used when step fails, we support Continue and Abort. Abort will fail the automation when the step fails. Continue will ignore the failure of current step and allow automation to run the next step. With conditional branching, we add step:stepName to support the automation to go to another specific step.</p>
        1216  +
    pub fn valid_next_steps(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1217  +
        let mut v = self.valid_next_steps.unwrap_or_default();
        1218  +
        v.push(input.into());
        1219  +
        self.valid_next_steps = ::std::option::Option::Some(v);
        1220  +
        self
        1221  +
    }
        1222  +
    /// <p>Strategies used when step fails, we support Continue and Abort. Abort will fail the automation when the step fails. Continue will ignore the failure of current step and allow automation to run the next step. With conditional branching, we add step:stepName to support the automation to go to another specific step.</p>
        1223  +
    pub fn set_valid_next_steps(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
        1224  +
        self.valid_next_steps = input;
        1225  +
        self
        1226  +
    }
        1227  +
    /// <p>Strategies used when step fails, we support Continue and Abort. Abort will fail the automation when the step fails. Continue will ignore the failure of current step and allow automation to run the next step. With conditional branching, we add step:stepName to support the automation to go to another specific step.</p>
        1228  +
    pub fn get_valid_next_steps(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
        1229  +
        &self.valid_next_steps
        1230  +
    }
        1231  +
    /// Appends an item to `targets`.
        1232  +
    ///
        1233  +
    /// To override the contents of this collection use [`set_targets`](Self::set_targets).
        1234  +
    ///
        1235  +
    /// <p>The targets for the step execution.</p>
        1236  +
    pub fn targets(mut self, input: crate::types::Target) -> Self {
        1237  +
        let mut v = self.targets.unwrap_or_default();
        1238  +
        v.push(input);
        1239  +
        self.targets = ::std::option::Option::Some(v);
        1240  +
        self
        1241  +
    }
        1242  +
    /// <p>The targets for the step execution.</p>
        1243  +
    pub fn set_targets(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Target>>) -> Self {
        1244  +
        self.targets = input;
        1245  +
        self
        1246  +
    }
        1247  +
    /// <p>The targets for the step execution.</p>
        1248  +
    pub fn get_targets(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Target>> {
        1249  +
        &self.targets
        1250  +
    }
        1251  +
    /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts targeted by the current Automation execution.</p>
        1252  +
    pub fn target_location(mut self, input: crate::types::TargetLocation) -> Self {
        1253  +
        self.target_location = ::std::option::Option::Some(input);
        1254  +
        self
        1255  +
    }
        1256  +
    /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts targeted by the current Automation execution.</p>
        1257  +
    pub fn set_target_location(mut self, input: ::std::option::Option<crate::types::TargetLocation>) -> Self {
        1258  +
        self.target_location = input;
        1259  +
        self
        1260  +
    }
        1261  +
    /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts targeted by the current Automation execution.</p>
        1262  +
    pub fn get_target_location(&self) -> &::std::option::Option<crate::types::TargetLocation> {
        1263  +
        &self.target_location
        1264  +
    }
        1265  +
    /// Appends an item to `triggered_alarms`.
        1266  +
    ///
        1267  +
    /// To override the contents of this collection use [`set_triggered_alarms`](Self::set_triggered_alarms).
        1268  +
    ///
        1269  +
    /// <p>The CloudWatch alarms that were invoked by the automation.</p>
        1270  +
    pub fn triggered_alarms(mut self, input: crate::types::AlarmStateInformation) -> Self {
        1271  +
        let mut v = self.triggered_alarms.unwrap_or_default();
        1272  +
        v.push(input);
        1273  +
        self.triggered_alarms = ::std::option::Option::Some(v);
        1274  +
        self
        1275  +
    }
        1276  +
    /// <p>The CloudWatch alarms that were invoked by the automation.</p>
        1277  +
    pub fn set_triggered_alarms(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>>) -> Self {
        1278  +
        self.triggered_alarms = input;
        1279  +
        self
        1280  +
    }
        1281  +
    /// <p>The CloudWatch alarms that were invoked by the automation.</p>
        1282  +
    pub fn get_triggered_alarms(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>> {
        1283  +
        &self.triggered_alarms
        1284  +
    }
        1285  +
    /// <p>Information about the parent step.</p>
        1286  +
    pub fn parent_step_details(mut self, input: crate::types::ParentStepDetails) -> Self {
        1287  +
        self.parent_step_details = ::std::option::Option::Some(input);
        1288  +
        self
        1289  +
    }
        1290  +
    /// <p>Information about the parent step.</p>
        1291  +
    pub fn set_parent_step_details(mut self, input: ::std::option::Option<crate::types::ParentStepDetails>) -> Self {
        1292  +
        self.parent_step_details = input;
        1293  +
        self
        1294  +
    }
        1295  +
    /// <p>Information about the parent step.</p>
        1296  +
    pub fn get_parent_step_details(&self) -> &::std::option::Option<crate::types::ParentStepDetails> {
        1297  +
        &self.parent_step_details
        1298  +
    }
        1299  +
    /// Consumes the builder and constructs a [`StepExecution`](crate::types::StepExecution).
        1300  +
    pub fn build(self) -> crate::types::StepExecution {
        1301  +
        crate::types::StepExecution {
        1302  +
            step_name: self.step_name,
        1303  +
            action: self.action,
        1304  +
            timeout_seconds: self.timeout_seconds,
        1305  +
            on_failure: self.on_failure,
        1306  +
            max_attempts: self.max_attempts,
        1307  +
            execution_start_time: self.execution_start_time,
        1308  +
            execution_end_time: self.execution_end_time,
        1309  +
            step_status: self.step_status,
        1310  +
            response_code: self.response_code,
        1311  +
            inputs: self.inputs,
        1312  +
            outputs: self.outputs,
        1313  +
            response: self.response,
        1314  +
            failure_message: self.failure_message,
        1315  +
            warning_message: self.warning_message,
        1316  +
            failure_details: self.failure_details,
        1317  +
            step_execution_id: self.step_execution_id,
        1318  +
            overridden_parameters: self.overridden_parameters,
        1319  +
            is_end: self.is_end,
        1320  +
            next_step: self.next_step,
        1321  +
            is_critical: self.is_critical,
        1322  +
            valid_next_steps: self.valid_next_steps,
        1323  +
            targets: self.targets,
        1324  +
            target_location: self.target_location,
        1325  +
            triggered_alarms: self.triggered_alarms,
        1326  +
            parent_step_details: self.parent_step_details,
        1327  +
        }
        1328  +
    }
        1329  +
}