AWS SDK

AWS SDK

rev. 2915cec5ef64cb1ed4992565a748d76a11505b3b (ignoring whitespace)

Files changed:

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

@@ -0,1 +0,204 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>A filter used to match specific automation executions. This is used to limit the scope of Automation execution information returned.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct AutomationExecutionFilter {
           7  +
    /// <p>One or more keys to limit the results.</p>
           8  +
    pub key: crate::types::AutomationExecutionFilterKey,
           9  +
    /// <p>The values used to limit the execution information associated with the filter's key.</p>
          10  +
    pub values: ::std::vec::Vec<::std::string::String>,
          11  +
}
          12  +
impl AutomationExecutionFilter {
          13  +
    /// <p>One or more keys to limit the results.</p>
          14  +
    pub fn key(&self) -> &crate::types::AutomationExecutionFilterKey {
          15  +
        &self.key
          16  +
    }
          17  +
    /// <p>The values used to limit the execution information associated with the filter's key.</p>
          18  +
    pub fn values(&self) -> &[::std::string::String] {
          19  +
        use std::ops::Deref;
          20  +
        self.values.deref()
          21  +
    }
          22  +
}
          23  +
static AUTOMATIONEXECUTIONFILTER_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          24  +
    ::aws_smithy_schema::ShapeId::from_parts(
          25  +
        "com.amazonaws.ssm#AutomationExecutionFilter$Key",
          26  +
        "com.amazonaws.ssm",
          27  +
        "AutomationExecutionFilter",
          28  +
    ),
          29  +
    ::aws_smithy_schema::ShapeType::String,
          30  +
    "Key",
          31  +
    0,
          32  +
);
          33  +
static AUTOMATIONEXECUTIONFILTER_MEMBER_VALUES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_parts(
          35  +
        "com.amazonaws.ssm#AutomationExecutionFilterValueList$member",
          36  +
        "com.amazonaws.ssm",
          37  +
        "AutomationExecutionFilterValueList",
          38  +
    ),
          39  +
    ::aws_smithy_schema::ShapeType::String,
          40  +
    "member",
          41  +
    0,
          42  +
);
          43  +
static AUTOMATIONEXECUTIONFILTER_MEMBER_VALUES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          44  +
    ::aws_smithy_schema::ShapeId::from_parts(
          45  +
        "com.amazonaws.ssm#AutomationExecutionFilter$Values",
          46  +
        "com.amazonaws.ssm",
          47  +
        "AutomationExecutionFilter",
          48  +
    ),
          49  +
    ::aws_smithy_schema::ShapeType::List,
          50  +
    "Values",
          51  +
    1,
          52  +
)
          53  +
.with_list_member(&AUTOMATIONEXECUTIONFILTER_MEMBER_VALUES_MEMBER);
          54  +
static AUTOMATIONEXECUTIONFILTER_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          55  +
    ::aws_smithy_schema::ShapeId::from_parts(
          56  +
        "com.amazonaws.ssm#AutomationExecutionFilter",
          57  +
        "com.amazonaws.ssm",
          58  +
        "AutomationExecutionFilter",
          59  +
    ),
          60  +
    ::aws_smithy_schema::ShapeType::Structure,
          61  +
    &[&AUTOMATIONEXECUTIONFILTER_MEMBER_KEY, &AUTOMATIONEXECUTIONFILTER_MEMBER_VALUES],
          62  +
);
          63  +
impl AutomationExecutionFilter {
          64  +
    /// The schema for this shape.
          65  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &AUTOMATIONEXECUTIONFILTER_SCHEMA;
          66  +
}
          67  +
impl ::aws_smithy_schema::serde::SerializableStruct for AutomationExecutionFilter {
          68  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          69  +
    fn serialize_members(
          70  +
        &self,
          71  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          72  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          73  +
        {
          74  +
            let val = &self.key;
          75  +
            ser.write_string(&AUTOMATIONEXECUTIONFILTER_MEMBER_KEY, val.as_str())?;
          76  +
        }
          77  +
        {
          78  +
            let val = &self.values;
          79  +
          80  +
            ser.write_list(
          81  +
                &AUTOMATIONEXECUTIONFILTER_MEMBER_VALUES,
          82  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          83  +
                    for item in val {
          84  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
          85  +
                    }
          86  +
                    Ok(())
          87  +
                },
          88  +
            )?;
          89  +
        }
          90  +
        Ok(())
          91  +
    }
          92  +
}
          93  +
impl AutomationExecutionFilter {
          94  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          95  +
    pub fn deserialize(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          97  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          98  +
        #[allow(unused_variables, unused_mut)]
          99  +
        let mut builder = Self::builder();
         100  +
        #[allow(
         101  +
            unused_variables,
         102  +
            unreachable_code,
         103  +
            clippy::single_match,
         104  +
            clippy::match_single_binding,
         105  +
            clippy::diverging_sub_expression
         106  +
        )]
         107  +
        deserializer.read_struct(&AUTOMATIONEXECUTIONFILTER_SCHEMA, &mut |member, deser| {
         108  +
            match member.member_index() {
         109  +
                Some(0) => {
         110  +
                    builder.key = Some(crate::types::AutomationExecutionFilterKey::from(deser.read_string(member)?.as_str()));
         111  +
                }
         112  +
                Some(1) => {
         113  +
                    builder.values = Some(deser.read_string_list(member)?);
         114  +
                }
         115  +
                _ => {}
         116  +
            }
         117  +
            Ok(())
         118  +
        })?;
         119  +
        builder.values = builder.values.or(Some(Vec::new()));
         120  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
         121  +
    }
         122  +
}
         123  +
impl AutomationExecutionFilter {
         124  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         125  +
    pub fn deserialize_with_response(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         127  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         128  +
        _status: u16,
         129  +
        _body: &[u8],
         130  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         131  +
        Self::deserialize(deserializer)
         132  +
    }
         133  +
}
         134  +
impl AutomationExecutionFilter {
         135  +
    /// Creates a new builder-style object to manufacture [`AutomationExecutionFilter`](crate::types::AutomationExecutionFilter).
         136  +
    pub fn builder() -> crate::types::builders::AutomationExecutionFilterBuilder {
         137  +
        crate::types::builders::AutomationExecutionFilterBuilder::default()
         138  +
    }
         139  +
}
         140  +
         141  +
/// A builder for [`AutomationExecutionFilter`](crate::types::AutomationExecutionFilter).
         142  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         143  +
#[non_exhaustive]
         144  +
pub struct AutomationExecutionFilterBuilder {
         145  +
    pub(crate) key: ::std::option::Option<crate::types::AutomationExecutionFilterKey>,
         146  +
    pub(crate) values: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         147  +
}
         148  +
impl AutomationExecutionFilterBuilder {
         149  +
    /// <p>One or more keys to limit the results.</p>
         150  +
    /// This field is required.
         151  +
    pub fn key(mut self, input: crate::types::AutomationExecutionFilterKey) -> Self {
         152  +
        self.key = ::std::option::Option::Some(input);
         153  +
        self
         154  +
    }
         155  +
    /// <p>One or more keys to limit the results.</p>
         156  +
    pub fn set_key(mut self, input: ::std::option::Option<crate::types::AutomationExecutionFilterKey>) -> Self {
         157  +
        self.key = input;
         158  +
        self
         159  +
    }
         160  +
    /// <p>One or more keys to limit the results.</p>
         161  +
    pub fn get_key(&self) -> &::std::option::Option<crate::types::AutomationExecutionFilterKey> {
         162  +
        &self.key
         163  +
    }
         164  +
    /// Appends an item to `values`.
         165  +
    ///
         166  +
    /// To override the contents of this collection use [`set_values`](Self::set_values).
         167  +
    ///
         168  +
    /// <p>The values used to limit the execution information associated with the filter's key.</p>
         169  +
    pub fn values(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         170  +
        let mut v = self.values.unwrap_or_default();
         171  +
        v.push(input.into());
         172  +
        self.values = ::std::option::Option::Some(v);
         173  +
        self
         174  +
    }
         175  +
    /// <p>The values used to limit the execution information associated with the filter's key.</p>
         176  +
    pub fn set_values(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         177  +
        self.values = input;
         178  +
        self
         179  +
    }
         180  +
    /// <p>The values used to limit the execution information associated with the filter's key.</p>
         181  +
    pub fn get_values(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         182  +
        &self.values
         183  +
    }
         184  +
    /// Consumes the builder and constructs a [`AutomationExecutionFilter`](crate::types::AutomationExecutionFilter).
         185  +
    /// This method will fail if any of the following fields are not set:
         186  +
    /// - [`key`](crate::types::builders::AutomationExecutionFilterBuilder::key)
         187  +
    /// - [`values`](crate::types::builders::AutomationExecutionFilterBuilder::values)
         188  +
    pub fn build(self) -> ::std::result::Result<crate::types::AutomationExecutionFilter, ::aws_smithy_types::error::operation::BuildError> {
         189  +
        ::std::result::Result::Ok(crate::types::AutomationExecutionFilter {
         190  +
            key: self.key.ok_or_else(|| {
         191  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
         192  +
                    "key",
         193  +
                    "key was not specified but it is required when building AutomationExecutionFilter",
         194  +
                )
         195  +
            })?,
         196  +
            values: self.values.ok_or_else(|| {
         197  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
         198  +
                    "values",
         199  +
                    "values was not specified but it is required when building AutomationExecutionFilter",
         200  +
                )
         201  +
            })?,
         202  +
        })
         203  +
    }
         204  +
}

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

@@ -0,1 +0,181 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// When writing a match expression against `AutomationExecutionFilterKey`, 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 automationexecutionfilterkey = unimplemented!();
          14  +
/// match automationexecutionfilterkey {
          15  +
///     AutomationExecutionFilterKey::AutomationSubtype => { /* ... */ },
          16  +
///     AutomationExecutionFilterKey::AutomationType => { /* ... */ },
          17  +
///     AutomationExecutionFilterKey::CurrentAction => { /* ... */ },
          18  +
///     AutomationExecutionFilterKey::DocumentNamePrefix => { /* ... */ },
          19  +
///     AutomationExecutionFilterKey::ExecutionId => { /* ... */ },
          20  +
///     AutomationExecutionFilterKey::ExecutionStatus => { /* ... */ },
          21  +
///     AutomationExecutionFilterKey::OpsItemId => { /* ... */ },
          22  +
///     AutomationExecutionFilterKey::ParentExecutionId => { /* ... */ },
          23  +
///     AutomationExecutionFilterKey::StartTimeAfter => { /* ... */ },
          24  +
///     AutomationExecutionFilterKey::StartTimeBefore => { /* ... */ },
          25  +
///     AutomationExecutionFilterKey::TagKey => { /* ... */ },
          26  +
///     AutomationExecutionFilterKey::TargetResourceGroup => { /* ... */ },
          27  +
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
          28  +
///     _ => { /* ... */ },
          29  +
/// }
          30  +
/// ```
          31  +
/// The above code demonstrates that when `automationexecutionfilterkey` represents
          32  +
/// `NewFeature`, the execution path will lead to the second last match arm,
          33  +
/// even though the enum does not contain a variant `AutomationExecutionFilterKey::NewFeature`
          34  +
/// in the current version of SDK. The reason is that the variable `other`,
          35  +
/// created by the `@` operator, is bound to
          36  +
/// `AutomationExecutionFilterKey::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
          37  +
/// and calling `as_str` on it yields `"NewFeature"`.
          38  +
/// This match expression is forward-compatible when executed with a newer
          39  +
/// version of SDK where the variant `AutomationExecutionFilterKey::NewFeature` is defined.
          40  +
/// Specifically, when `automationexecutionfilterkey` represents `NewFeature`,
          41  +
/// the execution path will hit the second last match arm as before by virtue of
          42  +
/// calling `as_str` on `AutomationExecutionFilterKey::NewFeature` also yielding `"NewFeature"`.
          43  +
///
          44  +
/// Explicitly matching on the `Unknown` variant should
          45  +
/// be avoided for two reasons:
          46  +
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
          47  +
/// - It might inadvertently shadow other intended match arms.
          48  +
///
          49  +
#[allow(missing_docs)] // documentation missing in model
          50  +
#[non_exhaustive]
          51  +
#[derive(
          52  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
          53  +
)]
          54  +
pub enum AutomationExecutionFilterKey {
          55  +
    #[allow(missing_docs)] // documentation missing in model
          56  +
    AutomationSubtype,
          57  +
    #[allow(missing_docs)] // documentation missing in model
          58  +
    AutomationType,
          59  +
    #[allow(missing_docs)] // documentation missing in model
          60  +
    CurrentAction,
          61  +
    #[allow(missing_docs)] // documentation missing in model
          62  +
    DocumentNamePrefix,
          63  +
    #[allow(missing_docs)] // documentation missing in model
          64  +
    ExecutionId,
          65  +
    #[allow(missing_docs)] // documentation missing in model
          66  +
    ExecutionStatus,
          67  +
    #[allow(missing_docs)] // documentation missing in model
          68  +
    OpsItemId,
          69  +
    #[allow(missing_docs)] // documentation missing in model
          70  +
    ParentExecutionId,
          71  +
    #[allow(missing_docs)] // documentation missing in model
          72  +
    StartTimeAfter,
          73  +
    #[allow(missing_docs)] // documentation missing in model
          74  +
    StartTimeBefore,
          75  +
    #[allow(missing_docs)] // documentation missing in model
          76  +
    TagKey,
          77  +
    #[allow(missing_docs)] // documentation missing in model
          78  +
    TargetResourceGroup,
          79  +
    /// `Unknown` contains new variants that have been added since this code was generated.
          80  +
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
          81  +
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
          82  +
}
          83  +
impl ::std::convert::From<&str> for AutomationExecutionFilterKey {
          84  +
    fn from(s: &str) -> Self {
          85  +
        match s {
          86  +
            "AutomationSubtype" => AutomationExecutionFilterKey::AutomationSubtype,
          87  +
            "AutomationType" => AutomationExecutionFilterKey::AutomationType,
          88  +
            "CurrentAction" => AutomationExecutionFilterKey::CurrentAction,
          89  +
            "DocumentNamePrefix" => AutomationExecutionFilterKey::DocumentNamePrefix,
          90  +
            "ExecutionId" => AutomationExecutionFilterKey::ExecutionId,
          91  +
            "ExecutionStatus" => AutomationExecutionFilterKey::ExecutionStatus,
          92  +
            "OpsItemId" => AutomationExecutionFilterKey::OpsItemId,
          93  +
            "ParentExecutionId" => AutomationExecutionFilterKey::ParentExecutionId,
          94  +
            "StartTimeAfter" => AutomationExecutionFilterKey::StartTimeAfter,
          95  +
            "StartTimeBefore" => AutomationExecutionFilterKey::StartTimeBefore,
          96  +
            "TagKey" => AutomationExecutionFilterKey::TagKey,
          97  +
            "TargetResourceGroup" => AutomationExecutionFilterKey::TargetResourceGroup,
          98  +
            other => AutomationExecutionFilterKey::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
          99  +
        }
         100  +
    }
         101  +
}
         102  +
impl ::std::str::FromStr for AutomationExecutionFilterKey {
         103  +
    type Err = ::std::convert::Infallible;
         104  +
         105  +
    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         106  +
        ::std::result::Result::Ok(AutomationExecutionFilterKey::from(s))
         107  +
    }
         108  +
}
         109  +
impl AutomationExecutionFilterKey {
         110  +
    /// Returns the `&str` value of the enum member.
         111  +
    pub fn as_str(&self) -> &str {
         112  +
        match self {
         113  +
            AutomationExecutionFilterKey::AutomationSubtype => "AutomationSubtype",
         114  +
            AutomationExecutionFilterKey::AutomationType => "AutomationType",
         115  +
            AutomationExecutionFilterKey::CurrentAction => "CurrentAction",
         116  +
            AutomationExecutionFilterKey::DocumentNamePrefix => "DocumentNamePrefix",
         117  +
            AutomationExecutionFilterKey::ExecutionId => "ExecutionId",
         118  +
            AutomationExecutionFilterKey::ExecutionStatus => "ExecutionStatus",
         119  +
            AutomationExecutionFilterKey::OpsItemId => "OpsItemId",
         120  +
            AutomationExecutionFilterKey::ParentExecutionId => "ParentExecutionId",
         121  +
            AutomationExecutionFilterKey::StartTimeAfter => "StartTimeAfter",
         122  +
            AutomationExecutionFilterKey::StartTimeBefore => "StartTimeBefore",
         123  +
            AutomationExecutionFilterKey::TagKey => "TagKey",
         124  +
            AutomationExecutionFilterKey::TargetResourceGroup => "TargetResourceGroup",
         125  +
            AutomationExecutionFilterKey::Unknown(value) => value.as_str(),
         126  +
        }
         127  +
    }
         128  +
    /// Returns all the `&str` representations of the enum members.
         129  +
    pub const fn values() -> &'static [&'static str] {
         130  +
        &[
         131  +
            "AutomationSubtype",
         132  +
            "AutomationType",
         133  +
            "CurrentAction",
         134  +
            "DocumentNamePrefix",
         135  +
            "ExecutionId",
         136  +
            "ExecutionStatus",
         137  +
            "OpsItemId",
         138  +
            "ParentExecutionId",
         139  +
            "StartTimeAfter",
         140  +
            "StartTimeBefore",
         141  +
            "TagKey",
         142  +
            "TargetResourceGroup",
         143  +
        ]
         144  +
    }
         145  +
}
         146  +
impl ::std::convert::AsRef<str> for AutomationExecutionFilterKey {
         147  +
    fn as_ref(&self) -> &str {
         148  +
        self.as_str()
         149  +
    }
         150  +
}
         151  +
impl AutomationExecutionFilterKey {
         152  +
    /// Parses the enum value while disallowing unknown variants.
         153  +
    ///
         154  +
    /// Unknown variants will result in an error.
         155  +
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         156  +
        match Self::from(value) {
         157  +
            #[allow(deprecated)]
         158  +
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
         159  +
            known => Ok(known),
         160  +
        }
         161  +
    }
         162  +
}
         163  +
impl ::std::fmt::Display for AutomationExecutionFilterKey {
         164  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         165  +
        match self {
         166  +
            AutomationExecutionFilterKey::AutomationSubtype => write!(f, "AutomationSubtype"),
         167  +
            AutomationExecutionFilterKey::AutomationType => write!(f, "AutomationType"),
         168  +
            AutomationExecutionFilterKey::CurrentAction => write!(f, "CurrentAction"),
         169  +
            AutomationExecutionFilterKey::DocumentNamePrefix => write!(f, "DocumentNamePrefix"),
         170  +
            AutomationExecutionFilterKey::ExecutionId => write!(f, "ExecutionId"),
         171  +
            AutomationExecutionFilterKey::ExecutionStatus => write!(f, "ExecutionStatus"),
         172  +
            AutomationExecutionFilterKey::OpsItemId => write!(f, "OpsItemId"),
         173  +
            AutomationExecutionFilterKey::ParentExecutionId => write!(f, "ParentExecutionId"),
         174  +
            AutomationExecutionFilterKey::StartTimeAfter => write!(f, "StartTimeAfter"),
         175  +
            AutomationExecutionFilterKey::StartTimeBefore => write!(f, "StartTimeBefore"),
         176  +
            AutomationExecutionFilterKey::TagKey => write!(f, "TagKey"),
         177  +
            AutomationExecutionFilterKey::TargetResourceGroup => write!(f, "TargetResourceGroup"),
         178  +
            AutomationExecutionFilterKey::Unknown(value) => write!(f, "{value}"),
         179  +
        }
         180  +
    }
         181  +
}

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

@@ -0,1 +0,575 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Information about the optional inputs that can be specified for an automation execution preview.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct AutomationExecutionInputs {
           7  +
    /// <p>Information about parameters that can be specified for the preview operation.</p>
           8  +
    pub parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
           9  +
    /// <p>The name of the parameter used as the target resource for the rate-controlled execution. Required if you specify targets.</p>
          10  +
    pub target_parameter_name: ::std::option::Option<::std::string::String>,
          11  +
    /// <p>Information about the resources that would be included in the actual runbook execution, if it were to be run. Both Targets and TargetMaps can't be specified together.</p>
          12  +
    pub targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
          13  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
          14  +
    pub target_maps:
          15  +
        ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
          16  +
    /// <p>Information about the Amazon Web Services Regions and Amazon Web Services accounts targeted by the Automation execution preview operation.</p>
          17  +
    pub target_locations: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>,
          18  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported.</p>
          19  +
    pub target_locations_url: ::std::option::Option<::std::string::String>,
          20  +
}
          21  +
impl AutomationExecutionInputs {
          22  +
    /// <p>Information about parameters that can be specified for the preview operation.</p>
          23  +
    pub fn parameters(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
          24  +
        self.parameters.as_ref()
          25  +
    }
          26  +
    /// <p>The name of the parameter used as the target resource for the rate-controlled execution. Required if you specify targets.</p>
          27  +
    pub fn target_parameter_name(&self) -> ::std::option::Option<&str> {
          28  +
        self.target_parameter_name.as_deref()
          29  +
    }
          30  +
    /// <p>Information about the resources that would be included in the actual runbook execution, if it were to be run. Both Targets and TargetMaps can't be specified together.</p>
          31  +
    ///
          32  +
    /// 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()`.
          33  +
    pub fn targets(&self) -> &[crate::types::Target] {
          34  +
        self.targets.as_deref().unwrap_or_default()
          35  +
    }
          36  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
          37  +
    ///
          38  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.target_maps.is_none()`.
          39  +
    pub fn target_maps(&self) -> &[::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>] {
          40  +
        self.target_maps.as_deref().unwrap_or_default()
          41  +
    }
          42  +
    /// <p>Information about the Amazon Web Services Regions and Amazon Web Services accounts targeted by the Automation execution preview operation.</p>
          43  +
    ///
          44  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.target_locations.is_none()`.
          45  +
    pub fn target_locations(&self) -> &[crate::types::TargetLocation] {
          46  +
        self.target_locations.as_deref().unwrap_or_default()
          47  +
    }
          48  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported.</p>
          49  +
    pub fn target_locations_url(&self) -> ::std::option::Option<&str> {
          50  +
        self.target_locations_url.as_deref()
          51  +
    }
          52  +
}
          53  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          54  +
    ::aws_smithy_schema::ShapeId::from_parts(
          55  +
        "com.amazonaws.ssm#AutomationParameterValueList$member",
          56  +
        "com.amazonaws.ssm",
          57  +
        "AutomationParameterValueList",
          58  +
    ),
          59  +
    ::aws_smithy_schema::ShapeType::String,
          60  +
    "member",
          61  +
    0,
          62  +
);
          63  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          64  +
    ::aws_smithy_schema::ShapeId::from_parts(
          65  +
        "com.amazonaws.ssm#AutomationParameterMap$key",
          66  +
        "com.amazonaws.ssm",
          67  +
        "AutomationParameterMap",
          68  +
    ),
          69  +
    ::aws_smithy_schema::ShapeType::String,
          70  +
    "key",
          71  +
    0,
          72  +
);
          73  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          74  +
    ::aws_smithy_schema::ShapeId::from_parts(
          75  +
        "com.amazonaws.ssm#AutomationParameterMap$value",
          76  +
        "com.amazonaws.ssm",
          77  +
        "AutomationParameterMap",
          78  +
    ),
          79  +
    ::aws_smithy_schema::ShapeType::List,
          80  +
    "value",
          81  +
    1,
          82  +
)
          83  +
.with_list_member(&AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_VALUE_MEMBER);
          84  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          85  +
    ::aws_smithy_schema::ShapeId::from_parts(
          86  +
        "com.amazonaws.ssm#AutomationExecutionInputs$Parameters",
          87  +
        "com.amazonaws.ssm",
          88  +
        "AutomationExecutionInputs",
          89  +
    ),
          90  +
    ::aws_smithy_schema::ShapeType::Map,
          91  +
    "Parameters",
          92  +
    0,
          93  +
)
          94  +
.with_map_members(
          95  +
    &AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_KEY,
          96  +
    &AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_VALUE,
          97  +
);
          98  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_PARAMETER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          99  +
    ::aws_smithy_schema::ShapeId::from_parts(
         100  +
        "com.amazonaws.ssm#AutomationExecutionInputs$TargetParameterName",
         101  +
        "com.amazonaws.ssm",
         102  +
        "AutomationExecutionInputs",
         103  +
    ),
         104  +
    ::aws_smithy_schema::ShapeType::String,
         105  +
    "TargetParameterName",
         106  +
    1,
         107  +
);
         108  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGETS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         109  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AutomationTargets$member", "com.amazonaws.ssm", "AutomationTargets"),
         110  +
    ::aws_smithy_schema::ShapeType::Structure,
         111  +
    "member",
         112  +
    0,
         113  +
);
         114  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGETS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         115  +
    ::aws_smithy_schema::ShapeId::from_parts(
         116  +
        "com.amazonaws.ssm#AutomationExecutionInputs$Targets",
         117  +
        "com.amazonaws.ssm",
         118  +
        "AutomationExecutionInputs",
         119  +
    ),
         120  +
    ::aws_smithy_schema::ShapeType::List,
         121  +
    "Targets",
         122  +
    2,
         123  +
)
         124  +
.with_list_member(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGETS_MEMBER);
         125  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> =
         126  +
    ::aws_smithy_schema::Schema::new_member(
         127  +
        ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMapValueList$member", "com.amazonaws.ssm", "TargetMapValueList"),
         128  +
        ::aws_smithy_schema::ShapeType::String,
         129  +
        "member",
         130  +
        0,
         131  +
    );
         132  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         133  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$key", "com.amazonaws.ssm", "TargetMap"),
         134  +
    ::aws_smithy_schema::ShapeType::String,
         135  +
    "key",
         136  +
    0,
         137  +
);
         138  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         139  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$value", "com.amazonaws.ssm", "TargetMap"),
         140  +
    ::aws_smithy_schema::ShapeType::List,
         141  +
    "value",
         142  +
    1,
         143  +
)
         144  +
.with_list_member(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER);
         145  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         146  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMaps$member", "com.amazonaws.ssm", "TargetMaps"),
         147  +
    ::aws_smithy_schema::ShapeType::Map,
         148  +
    "member",
         149  +
    0,
         150  +
)
         151  +
.with_map_members(
         152  +
    &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_KEY,
         153  +
    &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_VALUE,
         154  +
);
         155  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         156  +
    ::aws_smithy_schema::ShapeId::from_parts(
         157  +
        "com.amazonaws.ssm#AutomationExecutionInputs$TargetMaps",
         158  +
        "com.amazonaws.ssm",
         159  +
        "AutomationExecutionInputs",
         160  +
    ),
         161  +
    ::aws_smithy_schema::ShapeType::List,
         162  +
    "TargetMaps",
         163  +
    3,
         164  +
)
         165  +
.with_list_member(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER);
         166  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         167  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetLocations$member", "com.amazonaws.ssm", "TargetLocations"),
         168  +
    ::aws_smithy_schema::ShapeType::Structure,
         169  +
    "member",
         170  +
    0,
         171  +
);
         172  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         173  +
    ::aws_smithy_schema::ShapeId::from_parts(
         174  +
        "com.amazonaws.ssm#AutomationExecutionInputs$TargetLocations",
         175  +
        "com.amazonaws.ssm",
         176  +
        "AutomationExecutionInputs",
         177  +
    ),
         178  +
    ::aws_smithy_schema::ShapeType::List,
         179  +
    "TargetLocations",
         180  +
    4,
         181  +
)
         182  +
.with_list_member(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS_MEMBER);
         183  +
static AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS_URL: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         184  +
    ::aws_smithy_schema::ShapeId::from_parts(
         185  +
        "com.amazonaws.ssm#AutomationExecutionInputs$TargetLocationsURL",
         186  +
        "com.amazonaws.ssm",
         187  +
        "AutomationExecutionInputs",
         188  +
    ),
         189  +
    ::aws_smithy_schema::ShapeType::String,
         190  +
    "TargetLocationsURL",
         191  +
    5,
         192  +
);
         193  +
static AUTOMATIONEXECUTIONINPUTS_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         194  +
    ::aws_smithy_schema::ShapeId::from_parts(
         195  +
        "com.amazonaws.ssm#AutomationExecutionInputs",
         196  +
        "com.amazonaws.ssm",
         197  +
        "AutomationExecutionInputs",
         198  +
    ),
         199  +
    ::aws_smithy_schema::ShapeType::Structure,
         200  +
    &[
         201  +
        &AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS,
         202  +
        &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_PARAMETER_NAME,
         203  +
        &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGETS,
         204  +
        &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS,
         205  +
        &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS,
         206  +
        &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS_URL,
         207  +
    ],
         208  +
);
         209  +
impl AutomationExecutionInputs {
         210  +
    /// The schema for this shape.
         211  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &AUTOMATIONEXECUTIONINPUTS_SCHEMA;
         212  +
}
         213  +
impl ::aws_smithy_schema::serde::SerializableStruct for AutomationExecutionInputs {
         214  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         215  +
    fn serialize_members(
         216  +
        &self,
         217  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         218  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         219  +
        if let Some(ref val) = self.parameters {
         220  +
            ser.write_map(
         221  +
                &AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS,
         222  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         223  +
                    for (key, value) in val {
         224  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         225  +
         226  +
                        ser.write_list(
         227  +
                            &AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_VALUE,
         228  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         229  +
                                for item in value {
         230  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         231  +
                                }
         232  +
                                Ok(())
         233  +
                            },
         234  +
                        )?;
         235  +
                    }
         236  +
                    Ok(())
         237  +
                },
         238  +
            )?;
         239  +
        }
         240  +
        if let Some(ref val) = self.target_parameter_name {
         241  +
            ser.write_string(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_PARAMETER_NAME, val)?;
         242  +
        }
         243  +
        if let Some(ref val) = self.targets {
         244  +
            ser.write_list(
         245  +
                &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGETS,
         246  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         247  +
                    for item in val {
         248  +
                        ser.write_struct(crate::types::Target::SCHEMA, item)?;
         249  +
                    }
         250  +
                    Ok(())
         251  +
                },
         252  +
            )?;
         253  +
        }
         254  +
        if let Some(ref val) = self.target_maps {
         255  +
            ser.write_list(
         256  +
                &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS,
         257  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         258  +
                    for item in val {
         259  +
                        ser.write_map(
         260  +
                            &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER,
         261  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         262  +
                                for (key, value) in item {
         263  +
                                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         264  +
         265  +
                                    ser.write_list(
         266  +
                                        &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_VALUE,
         267  +
                                        &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         268  +
                                            for item in value {
         269  +
                                                ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         270  +
                                            }
         271  +
                                            Ok(())
         272  +
                                        },
         273  +
                                    )?;
         274  +
                                }
         275  +
                                Ok(())
         276  +
                            },
         277  +
                        )?;
         278  +
                    }
         279  +
                    Ok(())
         280  +
                },
         281  +
            )?;
         282  +
        }
         283  +
        if let Some(ref val) = self.target_locations {
         284  +
            ser.write_list(
         285  +
                &AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS,
         286  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         287  +
                    for item in val {
         288  +
                        ser.write_struct(crate::types::TargetLocation::SCHEMA, item)?;
         289  +
                    }
         290  +
                    Ok(())
         291  +
                },
         292  +
            )?;
         293  +
        }
         294  +
        if let Some(ref val) = self.target_locations_url {
         295  +
            ser.write_string(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_LOCATIONS_URL, val)?;
         296  +
        }
         297  +
        Ok(())
         298  +
    }
         299  +
}
         300  +
impl AutomationExecutionInputs {
         301  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         302  +
    pub fn deserialize(
         303  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         304  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         305  +
        #[allow(unused_variables, unused_mut)]
         306  +
        let mut builder = Self::builder();
         307  +
        #[allow(
         308  +
            unused_variables,
         309  +
            unreachable_code,
         310  +
            clippy::single_match,
         311  +
            clippy::match_single_binding,
         312  +
            clippy::diverging_sub_expression
         313  +
        )]
         314  +
        deserializer.read_struct(&AUTOMATIONEXECUTIONINPUTS_SCHEMA, &mut |member, deser| {
         315  +
            match member.member_index() {
         316  +
                Some(0) => {
         317  +
                    if deser.is_null() {
         318  +
                        deser.read_null()?;
         319  +
                    } else {
         320  +
                        builder.parameters = Some({
         321  +
                            let mut container = std::collections::HashMap::new();
         322  +
                            deser.read_map(member, &mut |key, deser| {
         323  +
                                container.insert(key, {
         324  +
                                    let mut list = Vec::new();
         325  +
                                    deser.read_list(&AUTOMATIONEXECUTIONINPUTS_MEMBER_PARAMETERS_VALUE, &mut |deser| {
         326  +
                                        list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
         327  +
                                        Ok(())
         328  +
                                    })?;
         329  +
                                    list
         330  +
                                });
         331  +
                                Ok(())
         332  +
                            })?;
         333  +
                            container
         334  +
                        });
         335  +
                    }
         336  +
                }
         337  +
                Some(1) => {
         338  +
                    if deser.is_null() {
         339  +
                        deser.read_null()?;
         340  +
                    } else {
         341  +
                        builder.target_parameter_name = Some(deser.read_string(member)?);
         342  +
                    }
         343  +
                }
         344  +
                Some(2) => {
         345  +
                    if deser.is_null() {
         346  +
                        deser.read_null()?;
         347  +
                    } else {
         348  +
                        builder.targets = Some({
         349  +
                            let mut container = Vec::new();
         350  +
                            deser.read_list(member, &mut |deser| {
         351  +
                                container.push(crate::types::Target::deserialize(deser)?);
         352  +
                                Ok(())
         353  +
                            })?;
         354  +
                            container
         355  +
                        });
         356  +
                    }
         357  +
                }
         358  +
                Some(3) => {
         359  +
                    if deser.is_null() {
         360  +
                        deser.read_null()?;
         361  +
                    } else {
         362  +
                        builder.target_maps = Some({
         363  +
                            let mut container = Vec::new();
         364  +
                            deser.read_list(member, &mut |deser| {
         365  +
                                container.push({
         366  +
                                    let mut map = ::std::collections::HashMap::new();
         367  +
                                    deser.read_map(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER, &mut |key, deser| {
         368  +
                                        let value = {
         369  +
                                            let mut list = Vec::new();
         370  +
                                            deser.read_list(&AUTOMATIONEXECUTIONINPUTS_MEMBER_TARGET_MAPS_MEMBER_VALUE, &mut |deser| {
         371  +
                                                list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
         372  +
                                                Ok(())
         373  +
                                            })?;
         374  +
                                            list
         375  +
                                        };
         376  +
                                        map.insert(key, value);
         377  +
                                        Ok(())
         378  +
                                    })?;
         379  +
                                    map
         380  +
                                });
         381  +
                                Ok(())
         382  +
                            })?;
         383  +
                            container
         384  +
                        });
         385  +
                    }
         386  +
                }
         387  +
                Some(4) => {
         388  +
                    if deser.is_null() {
         389  +
                        deser.read_null()?;
         390  +
                    } else {
         391  +
                        builder.target_locations = Some({
         392  +
                            let mut container = Vec::new();
         393  +
                            deser.read_list(member, &mut |deser| {
         394  +
                                container.push(crate::types::TargetLocation::deserialize(deser)?);
         395  +
                                Ok(())
         396  +
                            })?;
         397  +
                            container
         398  +
                        });
         399  +
                    }
         400  +
                }
         401  +
                Some(5) => {
         402  +
                    if deser.is_null() {
         403  +
                        deser.read_null()?;
         404  +
                    } else {
         405  +
                        builder.target_locations_url = Some(deser.read_string(member)?);
         406  +
                    }
         407  +
                }
         408  +
                _ => {}
         409  +
            }
         410  +
            Ok(())
         411  +
        })?;
         412  +
        Ok(builder.build())
         413  +
    }
         414  +
}
         415  +
impl AutomationExecutionInputs {
         416  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         417  +
    pub fn deserialize_with_response(
         418  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         419  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         420  +
        _status: u16,
         421  +
        _body: &[u8],
         422  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         423  +
        Self::deserialize(deserializer)
         424  +
    }
         425  +
}
         426  +
impl AutomationExecutionInputs {
         427  +
    /// Creates a new builder-style object to manufacture [`AutomationExecutionInputs`](crate::types::AutomationExecutionInputs).
         428  +
    pub fn builder() -> crate::types::builders::AutomationExecutionInputsBuilder {
         429  +
        crate::types::builders::AutomationExecutionInputsBuilder::default()
         430  +
    }
         431  +
}
         432  +
         433  +
/// A builder for [`AutomationExecutionInputs`](crate::types::AutomationExecutionInputs).
         434  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         435  +
#[non_exhaustive]
         436  +
pub struct AutomationExecutionInputsBuilder {
         437  +
    pub(crate) parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
         438  +
    pub(crate) target_parameter_name: ::std::option::Option<::std::string::String>,
         439  +
    pub(crate) targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
         440  +
    pub(crate) target_maps:
         441  +
        ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
         442  +
    pub(crate) target_locations: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>,
         443  +
    pub(crate) target_locations_url: ::std::option::Option<::std::string::String>,
         444  +
}
         445  +
impl AutomationExecutionInputsBuilder {
         446  +
    /// Adds a key-value pair to `parameters`.
         447  +
    ///
         448  +
    /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
         449  +
    ///
         450  +
    /// <p>Information about parameters that can be specified for the preview operation.</p>
         451  +
    pub fn parameters(mut self, k: impl ::std::convert::Into<::std::string::String>, v: ::std::vec::Vec<::std::string::String>) -> Self {
         452  +
        let mut hash_map = self.parameters.unwrap_or_default();
         453  +
        hash_map.insert(k.into(), v);
         454  +
        self.parameters = ::std::option::Option::Some(hash_map);
         455  +
        self
         456  +
    }
         457  +
    /// <p>Information about parameters that can be specified for the preview operation.</p>
         458  +
    pub fn set_parameters(
         459  +
        mut self,
         460  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
         461  +
    ) -> Self {
         462  +
        self.parameters = input;
         463  +
        self
         464  +
    }
         465  +
    /// <p>Information about parameters that can be specified for the preview operation.</p>
         466  +
    pub fn get_parameters(
         467  +
        &self,
         468  +
    ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         469  +
        &self.parameters
         470  +
    }
         471  +
    /// <p>The name of the parameter used as the target resource for the rate-controlled execution. Required if you specify targets.</p>
         472  +
    pub fn target_parameter_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         473  +
        self.target_parameter_name = ::std::option::Option::Some(input.into());
         474  +
        self
         475  +
    }
         476  +
    /// <p>The name of the parameter used as the target resource for the rate-controlled execution. Required if you specify targets.</p>
         477  +
    pub fn set_target_parameter_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         478  +
        self.target_parameter_name = input;
         479  +
        self
         480  +
    }
         481  +
    /// <p>The name of the parameter used as the target resource for the rate-controlled execution. Required if you specify targets.</p>
         482  +
    pub fn get_target_parameter_name(&self) -> &::std::option::Option<::std::string::String> {
         483  +
        &self.target_parameter_name
         484  +
    }
         485  +
    /// Appends an item to `targets`.
         486  +
    ///
         487  +
    /// To override the contents of this collection use [`set_targets`](Self::set_targets).
         488  +
    ///
         489  +
    /// <p>Information about the resources that would be included in the actual runbook execution, if it were to be run. Both Targets and TargetMaps can't be specified together.</p>
         490  +
    pub fn targets(mut self, input: crate::types::Target) -> Self {
         491  +
        let mut v = self.targets.unwrap_or_default();
         492  +
        v.push(input);
         493  +
        self.targets = ::std::option::Option::Some(v);
         494  +
        self
         495  +
    }
         496  +
    /// <p>Information about the resources that would be included in the actual runbook execution, if it were to be run. Both Targets and TargetMaps can't be specified together.</p>
         497  +
    pub fn set_targets(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Target>>) -> Self {
         498  +
        self.targets = input;
         499  +
        self
         500  +
    }
         501  +
    /// <p>Information about the resources that would be included in the actual runbook execution, if it were to be run. Both Targets and TargetMaps can't be specified together.</p>
         502  +
    pub fn get_targets(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Target>> {
         503  +
        &self.targets
         504  +
    }
         505  +
    /// Appends an item to `target_maps`.
         506  +
    ///
         507  +
    /// To override the contents of this collection use [`set_target_maps`](Self::set_target_maps).
         508  +
    ///
         509  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
         510  +
    pub fn target_maps(mut self, input: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>) -> Self {
         511  +
        let mut v = self.target_maps.unwrap_or_default();
         512  +
        v.push(input);
         513  +
        self.target_maps = ::std::option::Option::Some(v);
         514  +
        self
         515  +
    }
         516  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
         517  +
    pub fn set_target_maps(
         518  +
        mut self,
         519  +
        input: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
         520  +
    ) -> Self {
         521  +
        self.target_maps = input;
         522  +
        self
         523  +
    }
         524  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
         525  +
    pub fn get_target_maps(
         526  +
        &self,
         527  +
    ) -> &::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>> {
         528  +
        &self.target_maps
         529  +
    }
         530  +
    /// Appends an item to `target_locations`.
         531  +
    ///
         532  +
    /// To override the contents of this collection use [`set_target_locations`](Self::set_target_locations).
         533  +
    ///
         534  +
    /// <p>Information about the Amazon Web Services Regions and Amazon Web Services accounts targeted by the Automation execution preview operation.</p>
         535  +
    pub fn target_locations(mut self, input: crate::types::TargetLocation) -> Self {
         536  +
        let mut v = self.target_locations.unwrap_or_default();
         537  +
        v.push(input);
         538  +
        self.target_locations = ::std::option::Option::Some(v);
         539  +
        self
         540  +
    }
         541  +
    /// <p>Information about the Amazon Web Services Regions and Amazon Web Services accounts targeted by the Automation execution preview operation.</p>
         542  +
    pub fn set_target_locations(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>) -> Self {
         543  +
        self.target_locations = input;
         544  +
        self
         545  +
    }
         546  +
    /// <p>Information about the Amazon Web Services Regions and Amazon Web Services accounts targeted by the Automation execution preview operation.</p>
         547  +
    pub fn get_target_locations(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>> {
         548  +
        &self.target_locations
         549  +
    }
         550  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported.</p>
         551  +
    pub fn target_locations_url(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         552  +
        self.target_locations_url = ::std::option::Option::Some(input.into());
         553  +
        self
         554  +
    }
         555  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported.</p>
         556  +
    pub fn set_target_locations_url(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         557  +
        self.target_locations_url = input;
         558  +
        self
         559  +
    }
         560  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported.</p>
         561  +
    pub fn get_target_locations_url(&self) -> &::std::option::Option<::std::string::String> {
         562  +
        &self.target_locations_url
         563  +
    }
         564  +
    /// Consumes the builder and constructs a [`AutomationExecutionInputs`](crate::types::AutomationExecutionInputs).
         565  +
    pub fn build(self) -> crate::types::AutomationExecutionInputs {
         566  +
        crate::types::AutomationExecutionInputs {
         567  +
            parameters: self.parameters,
         568  +
            target_parameter_name: self.target_parameter_name,
         569  +
            targets: self.targets,
         570  +
            target_maps: self.target_maps,
         571  +
            target_locations: self.target_locations,
         572  +
            target_locations_url: self.target_locations_url,
         573  +
        }
         574  +
    }
         575  +
}

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

@@ -0,1 +0,1737 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Details about a specific Automation execution.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct AutomationExecutionMetadata {
           7  +
    /// <p>The execution ID.</p>
           8  +
    pub automation_execution_id: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>The name of the Automation runbook used during execution.</p>
          10  +
    pub document_name: ::std::option::Option<::std::string::String>,
          11  +
    /// <p>The document version used during the execution.</p>
          12  +
    pub document_version: ::std::option::Option<::std::string::String>,
          13  +
    /// <p>The status of the execution.</p>
          14  +
    pub automation_execution_status: ::std::option::Option<crate::types::AutomationExecutionStatus>,
          15  +
    /// <p>The time the execution started.</p>
          16  +
    pub execution_start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          17  +
    /// <p>The time the execution finished. This isn't populated if the execution is still in progress.</p>
          18  +
    pub execution_end_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          19  +
    /// <p>The IAM role ARN of the user who ran the automation.</p>
          20  +
    pub executed_by: ::std::option::Option<::std::string::String>,
          21  +
    /// <p>An S3 bucket where execution information is stored.</p>
          22  +
    pub log_file: ::std::option::Option<::std::string::String>,
          23  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
          24  +
    pub outputs: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
          25  +
    /// <p>The Automation execution mode.</p>
          26  +
    pub mode: ::std::option::Option<crate::types::ExecutionMode>,
          27  +
    /// <p>The execution ID of the parent automation.</p>
          28  +
    pub parent_automation_execution_id: ::std::option::Option<::std::string::String>,
          29  +
    /// <p>The name of the step that is currently running.</p>
          30  +
    pub current_step_name: ::std::option::Option<::std::string::String>,
          31  +
    /// <p>The action of the step that is currently running.</p>
          32  +
    pub current_action: ::std::option::Option<::std::string::String>,
          33  +
    /// <p>A message that describes a failure that occurred during the automation execution.</p>
          34  +
    pub failure_message: ::std::option::Option<::std::string::String>,
          35  +
    /// <p>A message that describes a non-critical issue that occurred during the automation execution.</p>
          36  +
    pub warning_message: ::std::option::Option<::std::string::String>,
          37  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
          38  +
    pub target_parameter_name: ::std::option::Option<::std::string::String>,
          39  +
    /// <p>The targets defined by the user when starting the automation.</p>
          40  +
    pub targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
          41  +
    /// <p>The specified key-value mapping of document parameters to target resources.</p>
          42  +
    pub target_maps:
          43  +
        ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
          44  +
    /// <p>A list of targets that resolved during the execution.</p>
          45  +
    pub resolved_targets: ::std::option::Option<crate::types::ResolvedTargets>,
          46  +
    /// <p>The <code>MaxConcurrency</code> value specified by the user when starting the automation.</p>
          47  +
    pub max_concurrency: ::std::option::Option<::std::string::String>,
          48  +
    /// <p>The <code>MaxErrors</code> value specified by the user when starting the automation.</p>
          49  +
    pub max_errors: ::std::option::Option<::std::string::String>,
          50  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
          51  +
    pub target: ::std::option::Option<::std::string::String>,
          52  +
    /// <p>Use this filter with <code>DescribeAutomationExecutions</code>. Specify either Local or CrossAccount. CrossAccount is an Automation that runs in multiple Amazon Web Services Regions and Amazon Web Services accounts. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation-multiple-accounts-and-regions.html">Running automations in multiple Amazon Web Services Regions and accounts</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
          53  +
    pub automation_type: ::std::option::Option<crate::types::AutomationType>,
          54  +
    /// <p>The details for the CloudWatch alarm applied to your automation.</p>
          55  +
    pub alarm_configuration: ::std::option::Option<crate::types::AlarmConfiguration>,
          56  +
    /// <p>The CloudWatch alarm that was invoked by the automation.</p>
          57  +
    pub triggered_alarms: ::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>>,
          58  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported</p>
          59  +
    pub target_locations_url: ::std::option::Option<::std::string::String>,
          60  +
    /// <p>The subtype of the Automation operation. Currently, the only supported value is <code>ChangeRequest</code>.</p>
          61  +
    pub automation_subtype: ::std::option::Option<crate::types::AutomationSubtype>,
          62  +
    /// <p>The date and time the Automation operation is scheduled to start.</p>
          63  +
    pub scheduled_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          64  +
    /// <p>Information about the Automation runbooks that are run during a runbook workflow in Change Manager.</p><note>
          65  +
    /// <p>The Automation runbooks specified for the runbook workflow can't run until all required approvals for the change request have been received.</p>
          66  +
    /// </note>
          67  +
    pub runbooks: ::std::option::Option<::std::vec::Vec<crate::types::Runbook>>,
          68  +
    /// <p>The ID of an OpsItem that is created to represent a Change Manager change request.</p>
          69  +
    pub ops_item_id: ::std::option::Option<::std::string::String>,
          70  +
    /// <p>The ID of a State Manager association used in the Automation operation.</p>
          71  +
    pub association_id: ::std::option::Option<::std::string::String>,
          72  +
    /// <p>The name of the Change Manager change request.</p>
          73  +
    pub change_request_name: ::std::option::Option<::std::string::String>,
          74  +
}
          75  +
impl AutomationExecutionMetadata {
          76  +
    /// <p>The execution ID.</p>
          77  +
    pub fn automation_execution_id(&self) -> ::std::option::Option<&str> {
          78  +
        self.automation_execution_id.as_deref()
          79  +
    }
          80  +
    /// <p>The name of the Automation runbook used during execution.</p>
          81  +
    pub fn document_name(&self) -> ::std::option::Option<&str> {
          82  +
        self.document_name.as_deref()
          83  +
    }
          84  +
    /// <p>The document version used during the execution.</p>
          85  +
    pub fn document_version(&self) -> ::std::option::Option<&str> {
          86  +
        self.document_version.as_deref()
          87  +
    }
          88  +
    /// <p>The status of the execution.</p>
          89  +
    pub fn automation_execution_status(&self) -> ::std::option::Option<&crate::types::AutomationExecutionStatus> {
          90  +
        self.automation_execution_status.as_ref()
          91  +
    }
          92  +
    /// <p>The time the execution started.</p>
          93  +
    pub fn execution_start_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          94  +
        self.execution_start_time.as_ref()
          95  +
    }
          96  +
    /// <p>The time the execution finished. This isn't populated if the execution is still in progress.</p>
          97  +
    pub fn execution_end_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          98  +
        self.execution_end_time.as_ref()
          99  +
    }
         100  +
    /// <p>The IAM role ARN of the user who ran the automation.</p>
         101  +
    pub fn executed_by(&self) -> ::std::option::Option<&str> {
         102  +
        self.executed_by.as_deref()
         103  +
    }
         104  +
    /// <p>An S3 bucket where execution information is stored.</p>
         105  +
    pub fn log_file(&self) -> ::std::option::Option<&str> {
         106  +
        self.log_file.as_deref()
         107  +
    }
         108  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
         109  +
    pub fn outputs(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         110  +
        self.outputs.as_ref()
         111  +
    }
         112  +
    /// <p>The Automation execution mode.</p>
         113  +
    pub fn mode(&self) -> ::std::option::Option<&crate::types::ExecutionMode> {
         114  +
        self.mode.as_ref()
         115  +
    }
         116  +
    /// <p>The execution ID of the parent automation.</p>
         117  +
    pub fn parent_automation_execution_id(&self) -> ::std::option::Option<&str> {
         118  +
        self.parent_automation_execution_id.as_deref()
         119  +
    }
         120  +
    /// <p>The name of the step that is currently running.</p>
         121  +
    pub fn current_step_name(&self) -> ::std::option::Option<&str> {
         122  +
        self.current_step_name.as_deref()
         123  +
    }
         124  +
    /// <p>The action of the step that is currently running.</p>
         125  +
    pub fn current_action(&self) -> ::std::option::Option<&str> {
         126  +
        self.current_action.as_deref()
         127  +
    }
         128  +
    /// <p>A message that describes a failure that occurred during the automation execution.</p>
         129  +
    pub fn failure_message(&self) -> ::std::option::Option<&str> {
         130  +
        self.failure_message.as_deref()
         131  +
    }
         132  +
    /// <p>A message that describes a non-critical issue that occurred during the automation execution.</p>
         133  +
    pub fn warning_message(&self) -> ::std::option::Option<&str> {
         134  +
        self.warning_message.as_deref()
         135  +
    }
         136  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
         137  +
    pub fn target_parameter_name(&self) -> ::std::option::Option<&str> {
         138  +
        self.target_parameter_name.as_deref()
         139  +
    }
         140  +
    /// <p>The targets defined by the user when starting the automation.</p>
         141  +
    ///
         142  +
    /// 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()`.
         143  +
    pub fn targets(&self) -> &[crate::types::Target] {
         144  +
        self.targets.as_deref().unwrap_or_default()
         145  +
    }
         146  +
    /// <p>The specified key-value mapping of document parameters to target resources.</p>
         147  +
    ///
         148  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.target_maps.is_none()`.
         149  +
    pub fn target_maps(&self) -> &[::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>] {
         150  +
        self.target_maps.as_deref().unwrap_or_default()
         151  +
    }
         152  +
    /// <p>A list of targets that resolved during the execution.</p>
         153  +
    pub fn resolved_targets(&self) -> ::std::option::Option<&crate::types::ResolvedTargets> {
         154  +
        self.resolved_targets.as_ref()
         155  +
    }
         156  +
    /// <p>The <code>MaxConcurrency</code> value specified by the user when starting the automation.</p>
         157  +
    pub fn max_concurrency(&self) -> ::std::option::Option<&str> {
         158  +
        self.max_concurrency.as_deref()
         159  +
    }
         160  +
    /// <p>The <code>MaxErrors</code> value specified by the user when starting the automation.</p>
         161  +
    pub fn max_errors(&self) -> ::std::option::Option<&str> {
         162  +
        self.max_errors.as_deref()
         163  +
    }
         164  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
         165  +
    pub fn target(&self) -> ::std::option::Option<&str> {
         166  +
        self.target.as_deref()
         167  +
    }
         168  +
    /// <p>Use this filter with <code>DescribeAutomationExecutions</code>. Specify either Local or CrossAccount. CrossAccount is an Automation that runs in multiple Amazon Web Services Regions and Amazon Web Services accounts. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation-multiple-accounts-and-regions.html">Running automations in multiple Amazon Web Services Regions and accounts</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         169  +
    pub fn automation_type(&self) -> ::std::option::Option<&crate::types::AutomationType> {
         170  +
        self.automation_type.as_ref()
         171  +
    }
         172  +
    /// <p>The details for the CloudWatch alarm applied to your automation.</p>
         173  +
    pub fn alarm_configuration(&self) -> ::std::option::Option<&crate::types::AlarmConfiguration> {
         174  +
        self.alarm_configuration.as_ref()
         175  +
    }
         176  +
    /// <p>The CloudWatch alarm that was invoked by the automation.</p>
         177  +
    ///
         178  +
    /// 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()`.
         179  +
    pub fn triggered_alarms(&self) -> &[crate::types::AlarmStateInformation] {
         180  +
        self.triggered_alarms.as_deref().unwrap_or_default()
         181  +
    }
         182  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported</p>
         183  +
    pub fn target_locations_url(&self) -> ::std::option::Option<&str> {
         184  +
        self.target_locations_url.as_deref()
         185  +
    }
         186  +
    /// <p>The subtype of the Automation operation. Currently, the only supported value is <code>ChangeRequest</code>.</p>
         187  +
    pub fn automation_subtype(&self) -> ::std::option::Option<&crate::types::AutomationSubtype> {
         188  +
        self.automation_subtype.as_ref()
         189  +
    }
         190  +
    /// <p>The date and time the Automation operation is scheduled to start.</p>
         191  +
    pub fn scheduled_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         192  +
        self.scheduled_time.as_ref()
         193  +
    }
         194  +
    /// <p>Information about the Automation runbooks that are run during a runbook workflow in Change Manager.</p><note>
         195  +
    /// <p>The Automation runbooks specified for the runbook workflow can't run until all required approvals for the change request have been received.</p>
         196  +
    /// </note>
         197  +
    ///
         198  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.runbooks.is_none()`.
         199  +
    pub fn runbooks(&self) -> &[crate::types::Runbook] {
         200  +
        self.runbooks.as_deref().unwrap_or_default()
         201  +
    }
         202  +
    /// <p>The ID of an OpsItem that is created to represent a Change Manager change request.</p>
         203  +
    pub fn ops_item_id(&self) -> ::std::option::Option<&str> {
         204  +
        self.ops_item_id.as_deref()
         205  +
    }
         206  +
    /// <p>The ID of a State Manager association used in the Automation operation.</p>
         207  +
    pub fn association_id(&self) -> ::std::option::Option<&str> {
         208  +
        self.association_id.as_deref()
         209  +
    }
         210  +
    /// <p>The name of the Change Manager change request.</p>
         211  +
    pub fn change_request_name(&self) -> ::std::option::Option<&str> {
         212  +
        self.change_request_name.as_deref()
         213  +
    }
         214  +
}
         215  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_EXECUTION_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         216  +
    ::aws_smithy_schema::ShapeId::from_parts(
         217  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$AutomationExecutionId",
         218  +
        "com.amazonaws.ssm",
         219  +
        "AutomationExecutionMetadata",
         220  +
    ),
         221  +
    ::aws_smithy_schema::ShapeType::String,
         222  +
    "AutomationExecutionId",
         223  +
    0,
         224  +
);
         225  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_DOCUMENT_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         226  +
    ::aws_smithy_schema::ShapeId::from_parts(
         227  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$DocumentName",
         228  +
        "com.amazonaws.ssm",
         229  +
        "AutomationExecutionMetadata",
         230  +
    ),
         231  +
    ::aws_smithy_schema::ShapeType::String,
         232  +
    "DocumentName",
         233  +
    1,
         234  +
);
         235  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_DOCUMENT_VERSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         236  +
    ::aws_smithy_schema::ShapeId::from_parts(
         237  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$DocumentVersion",
         238  +
        "com.amazonaws.ssm",
         239  +
        "AutomationExecutionMetadata",
         240  +
    ),
         241  +
    ::aws_smithy_schema::ShapeType::String,
         242  +
    "DocumentVersion",
         243  +
    2,
         244  +
);
         245  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_EXECUTION_STATUS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         246  +
    ::aws_smithy_schema::ShapeId::from_parts(
         247  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$AutomationExecutionStatus",
         248  +
        "com.amazonaws.ssm",
         249  +
        "AutomationExecutionMetadata",
         250  +
    ),
         251  +
    ::aws_smithy_schema::ShapeType::String,
         252  +
    "AutomationExecutionStatus",
         253  +
    3,
         254  +
);
         255  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTION_START_TIME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         256  +
    ::aws_smithy_schema::ShapeId::from_parts(
         257  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$ExecutionStartTime",
         258  +
        "com.amazonaws.ssm",
         259  +
        "AutomationExecutionMetadata",
         260  +
    ),
         261  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         262  +
    "ExecutionStartTime",
         263  +
    4,
         264  +
);
         265  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTION_END_TIME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         266  +
    ::aws_smithy_schema::ShapeId::from_parts(
         267  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$ExecutionEndTime",
         268  +
        "com.amazonaws.ssm",
         269  +
        "AutomationExecutionMetadata",
         270  +
    ),
         271  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         272  +
    "ExecutionEndTime",
         273  +
    5,
         274  +
);
         275  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTED_BY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         276  +
    ::aws_smithy_schema::ShapeId::from_parts(
         277  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$ExecutedBy",
         278  +
        "com.amazonaws.ssm",
         279  +
        "AutomationExecutionMetadata",
         280  +
    ),
         281  +
    ::aws_smithy_schema::ShapeType::String,
         282  +
    "ExecutedBy",
         283  +
    6,
         284  +
);
         285  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_LOG_FILE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         286  +
    ::aws_smithy_schema::ShapeId::from_parts(
         287  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$LogFile",
         288  +
        "com.amazonaws.ssm",
         289  +
        "AutomationExecutionMetadata",
         290  +
    ),
         291  +
    ::aws_smithy_schema::ShapeType::String,
         292  +
    "LogFile",
         293  +
    7,
         294  +
);
         295  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         296  +
    ::aws_smithy_schema::ShapeId::from_parts(
         297  +
        "com.amazonaws.ssm#AutomationParameterValueList$member",
         298  +
        "com.amazonaws.ssm",
         299  +
        "AutomationParameterValueList",
         300  +
    ),
         301  +
    ::aws_smithy_schema::ShapeType::String,
         302  +
    "member",
         303  +
    0,
         304  +
);
         305  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         306  +
    ::aws_smithy_schema::ShapeId::from_parts(
         307  +
        "com.amazonaws.ssm#AutomationParameterMap$key",
         308  +
        "com.amazonaws.ssm",
         309  +
        "AutomationParameterMap",
         310  +
    ),
         311  +
    ::aws_smithy_schema::ShapeType::String,
         312  +
    "key",
         313  +
    0,
         314  +
);
         315  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         316  +
    ::aws_smithy_schema::ShapeId::from_parts(
         317  +
        "com.amazonaws.ssm#AutomationParameterMap$value",
         318  +
        "com.amazonaws.ssm",
         319  +
        "AutomationParameterMap",
         320  +
    ),
         321  +
    ::aws_smithy_schema::ShapeType::List,
         322  +
    "value",
         323  +
    1,
         324  +
)
         325  +
.with_list_member(&AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_VALUE_MEMBER);
         326  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         327  +
    ::aws_smithy_schema::ShapeId::from_parts(
         328  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$Outputs",
         329  +
        "com.amazonaws.ssm",
         330  +
        "AutomationExecutionMetadata",
         331  +
    ),
         332  +
    ::aws_smithy_schema::ShapeType::Map,
         333  +
    "Outputs",
         334  +
    8,
         335  +
)
         336  +
.with_map_members(
         337  +
    &AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_KEY,
         338  +
    &AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_VALUE,
         339  +
);
         340  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_MODE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         341  +
    ::aws_smithy_schema::ShapeId::from_parts(
         342  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$Mode",
         343  +
        "com.amazonaws.ssm",
         344  +
        "AutomationExecutionMetadata",
         345  +
    ),
         346  +
    ::aws_smithy_schema::ShapeType::String,
         347  +
    "Mode",
         348  +
    9,
         349  +
);
         350  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_PARENT_AUTOMATION_EXECUTION_ID: ::aws_smithy_schema::Schema<'static> =
         351  +
    ::aws_smithy_schema::Schema::new_member(
         352  +
        ::aws_smithy_schema::ShapeId::from_parts(
         353  +
            "com.amazonaws.ssm#AutomationExecutionMetadata$ParentAutomationExecutionId",
         354  +
            "com.amazonaws.ssm",
         355  +
            "AutomationExecutionMetadata",
         356  +
        ),
         357  +
        ::aws_smithy_schema::ShapeType::String,
         358  +
        "ParentAutomationExecutionId",
         359  +
        10,
         360  +
    );
         361  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_CURRENT_STEP_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         362  +
    ::aws_smithy_schema::ShapeId::from_parts(
         363  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$CurrentStepName",
         364  +
        "com.amazonaws.ssm",
         365  +
        "AutomationExecutionMetadata",
         366  +
    ),
         367  +
    ::aws_smithy_schema::ShapeType::String,
         368  +
    "CurrentStepName",
         369  +
    11,
         370  +
);
         371  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_CURRENT_ACTION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         372  +
    ::aws_smithy_schema::ShapeId::from_parts(
         373  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$CurrentAction",
         374  +
        "com.amazonaws.ssm",
         375  +
        "AutomationExecutionMetadata",
         376  +
    ),
         377  +
    ::aws_smithy_schema::ShapeType::String,
         378  +
    "CurrentAction",
         379  +
    12,
         380  +
);
         381  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_FAILURE_MESSAGE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         382  +
    ::aws_smithy_schema::ShapeId::from_parts(
         383  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$FailureMessage",
         384  +
        "com.amazonaws.ssm",
         385  +
        "AutomationExecutionMetadata",
         386  +
    ),
         387  +
    ::aws_smithy_schema::ShapeType::String,
         388  +
    "FailureMessage",
         389  +
    13,
         390  +
);
         391  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_WARNING_MESSAGE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         392  +
    ::aws_smithy_schema::ShapeId::from_parts(
         393  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$WarningMessage",
         394  +
        "com.amazonaws.ssm",
         395  +
        "AutomationExecutionMetadata",
         396  +
    ),
         397  +
    ::aws_smithy_schema::ShapeType::String,
         398  +
    "WarningMessage",
         399  +
    14,
         400  +
);
         401  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_PARAMETER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         402  +
    ::aws_smithy_schema::ShapeId::from_parts(
         403  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$TargetParameterName",
         404  +
        "com.amazonaws.ssm",
         405  +
        "AutomationExecutionMetadata",
         406  +
    ),
         407  +
    ::aws_smithy_schema::ShapeType::String,
         408  +
    "TargetParameterName",
         409  +
    15,
         410  +
);
         411  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGETS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         412  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Targets$member", "com.amazonaws.ssm", "Targets"),
         413  +
    ::aws_smithy_schema::ShapeType::Structure,
         414  +
    "member",
         415  +
    0,
         416  +
);
         417  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGETS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         418  +
    ::aws_smithy_schema::ShapeId::from_parts(
         419  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$Targets",
         420  +
        "com.amazonaws.ssm",
         421  +
        "AutomationExecutionMetadata",
         422  +
    ),
         423  +
    ::aws_smithy_schema::ShapeType::List,
         424  +
    "Targets",
         425  +
    16,
         426  +
)
         427  +
.with_list_member(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGETS_MEMBER);
         428  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> =
         429  +
    ::aws_smithy_schema::Schema::new_member(
         430  +
        ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMapValueList$member", "com.amazonaws.ssm", "TargetMapValueList"),
         431  +
        ::aws_smithy_schema::ShapeType::String,
         432  +
        "member",
         433  +
        0,
         434  +
    );
         435  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         436  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$key", "com.amazonaws.ssm", "TargetMap"),
         437  +
    ::aws_smithy_schema::ShapeType::String,
         438  +
    "key",
         439  +
    0,
         440  +
);
         441  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         442  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$value", "com.amazonaws.ssm", "TargetMap"),
         443  +
    ::aws_smithy_schema::ShapeType::List,
         444  +
    "value",
         445  +
    1,
         446  +
)
         447  +
.with_list_member(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER);
         448  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         449  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMaps$member", "com.amazonaws.ssm", "TargetMaps"),
         450  +
    ::aws_smithy_schema::ShapeType::Map,
         451  +
    "member",
         452  +
    0,
         453  +
)
         454  +
.with_map_members(
         455  +
    &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_KEY,
         456  +
    &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_VALUE,
         457  +
);
         458  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         459  +
    ::aws_smithy_schema::ShapeId::from_parts(
         460  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$TargetMaps",
         461  +
        "com.amazonaws.ssm",
         462  +
        "AutomationExecutionMetadata",
         463  +
    ),
         464  +
    ::aws_smithy_schema::ShapeType::List,
         465  +
    "TargetMaps",
         466  +
    17,
         467  +
)
         468  +
.with_list_member(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER);
         469  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_RESOLVED_TARGETS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         470  +
    ::aws_smithy_schema::ShapeId::from_parts(
         471  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$ResolvedTargets",
         472  +
        "com.amazonaws.ssm",
         473  +
        "AutomationExecutionMetadata",
         474  +
    ),
         475  +
    ::aws_smithy_schema::ShapeType::Structure,
         476  +
    "ResolvedTargets",
         477  +
    18,
         478  +
);
         479  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_MAX_CONCURRENCY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         480  +
    ::aws_smithy_schema::ShapeId::from_parts(
         481  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$MaxConcurrency",
         482  +
        "com.amazonaws.ssm",
         483  +
        "AutomationExecutionMetadata",
         484  +
    ),
         485  +
    ::aws_smithy_schema::ShapeType::String,
         486  +
    "MaxConcurrency",
         487  +
    19,
         488  +
);
         489  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_MAX_ERRORS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         490  +
    ::aws_smithy_schema::ShapeId::from_parts(
         491  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$MaxErrors",
         492  +
        "com.amazonaws.ssm",
         493  +
        "AutomationExecutionMetadata",
         494  +
    ),
         495  +
    ::aws_smithy_schema::ShapeType::String,
         496  +
    "MaxErrors",
         497  +
    20,
         498  +
);
         499  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         500  +
    ::aws_smithy_schema::ShapeId::from_parts(
         501  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$Target",
         502  +
        "com.amazonaws.ssm",
         503  +
        "AutomationExecutionMetadata",
         504  +
    ),
         505  +
    ::aws_smithy_schema::ShapeType::String,
         506  +
    "Target",
         507  +
    21,
         508  +
);
         509  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_TYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         510  +
    ::aws_smithy_schema::ShapeId::from_parts(
         511  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$AutomationType",
         512  +
        "com.amazonaws.ssm",
         513  +
        "AutomationExecutionMetadata",
         514  +
    ),
         515  +
    ::aws_smithy_schema::ShapeType::String,
         516  +
    "AutomationType",
         517  +
    22,
         518  +
);
         519  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_ALARM_CONFIGURATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         520  +
    ::aws_smithy_schema::ShapeId::from_parts(
         521  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$AlarmConfiguration",
         522  +
        "com.amazonaws.ssm",
         523  +
        "AutomationExecutionMetadata",
         524  +
    ),
         525  +
    ::aws_smithy_schema::ShapeType::Structure,
         526  +
    "AlarmConfiguration",
         527  +
    23,
         528  +
);
         529  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TRIGGERED_ALARMS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         530  +
    ::aws_smithy_schema::ShapeId::from_parts(
         531  +
        "com.amazonaws.ssm#AlarmStateInformationList$member",
         532  +
        "com.amazonaws.ssm",
         533  +
        "AlarmStateInformationList",
         534  +
    ),
         535  +
    ::aws_smithy_schema::ShapeType::Structure,
         536  +
    "member",
         537  +
    0,
         538  +
);
         539  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TRIGGERED_ALARMS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         540  +
    ::aws_smithy_schema::ShapeId::from_parts(
         541  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$TriggeredAlarms",
         542  +
        "com.amazonaws.ssm",
         543  +
        "AutomationExecutionMetadata",
         544  +
    ),
         545  +
    ::aws_smithy_schema::ShapeType::List,
         546  +
    "TriggeredAlarms",
         547  +
    24,
         548  +
)
         549  +
.with_list_member(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TRIGGERED_ALARMS_MEMBER);
         550  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_LOCATIONS_URL: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         551  +
    ::aws_smithy_schema::ShapeId::from_parts(
         552  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$TargetLocationsURL",
         553  +
        "com.amazonaws.ssm",
         554  +
        "AutomationExecutionMetadata",
         555  +
    ),
         556  +
    ::aws_smithy_schema::ShapeType::String,
         557  +
    "TargetLocationsURL",
         558  +
    25,
         559  +
);
         560  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_SUBTYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         561  +
    ::aws_smithy_schema::ShapeId::from_parts(
         562  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$AutomationSubtype",
         563  +
        "com.amazonaws.ssm",
         564  +
        "AutomationExecutionMetadata",
         565  +
    ),
         566  +
    ::aws_smithy_schema::ShapeType::String,
         567  +
    "AutomationSubtype",
         568  +
    26,
         569  +
);
         570  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_SCHEDULED_TIME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         571  +
    ::aws_smithy_schema::ShapeId::from_parts(
         572  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$ScheduledTime",
         573  +
        "com.amazonaws.ssm",
         574  +
        "AutomationExecutionMetadata",
         575  +
    ),
         576  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         577  +
    "ScheduledTime",
         578  +
    27,
         579  +
);
         580  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_RUNBOOKS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         581  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Runbooks$member", "com.amazonaws.ssm", "Runbooks"),
         582  +
    ::aws_smithy_schema::ShapeType::Structure,
         583  +
    "member",
         584  +
    0,
         585  +
);
         586  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_RUNBOOKS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         587  +
    ::aws_smithy_schema::ShapeId::from_parts(
         588  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$Runbooks",
         589  +
        "com.amazonaws.ssm",
         590  +
        "AutomationExecutionMetadata",
         591  +
    ),
         592  +
    ::aws_smithy_schema::ShapeType::List,
         593  +
    "Runbooks",
         594  +
    28,
         595  +
)
         596  +
.with_list_member(&AUTOMATIONEXECUTIONMETADATA_MEMBER_RUNBOOKS_MEMBER);
         597  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_OPS_ITEM_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         598  +
    ::aws_smithy_schema::ShapeId::from_parts(
         599  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$OpsItemId",
         600  +
        "com.amazonaws.ssm",
         601  +
        "AutomationExecutionMetadata",
         602  +
    ),
         603  +
    ::aws_smithy_schema::ShapeType::String,
         604  +
    "OpsItemId",
         605  +
    29,
         606  +
);
         607  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_ASSOCIATION_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         608  +
    ::aws_smithy_schema::ShapeId::from_parts(
         609  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$AssociationId",
         610  +
        "com.amazonaws.ssm",
         611  +
        "AutomationExecutionMetadata",
         612  +
    ),
         613  +
    ::aws_smithy_schema::ShapeType::String,
         614  +
    "AssociationId",
         615  +
    30,
         616  +
);
         617  +
static AUTOMATIONEXECUTIONMETADATA_MEMBER_CHANGE_REQUEST_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         618  +
    ::aws_smithy_schema::ShapeId::from_parts(
         619  +
        "com.amazonaws.ssm#AutomationExecutionMetadata$ChangeRequestName",
         620  +
        "com.amazonaws.ssm",
         621  +
        "AutomationExecutionMetadata",
         622  +
    ),
         623  +
    ::aws_smithy_schema::ShapeType::String,
         624  +
    "ChangeRequestName",
         625  +
    31,
         626  +
);
         627  +
static AUTOMATIONEXECUTIONMETADATA_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         628  +
    ::aws_smithy_schema::ShapeId::from_parts(
         629  +
        "com.amazonaws.ssm#AutomationExecutionMetadata",
         630  +
        "com.amazonaws.ssm",
         631  +
        "AutomationExecutionMetadata",
         632  +
    ),
         633  +
    ::aws_smithy_schema::ShapeType::Structure,
         634  +
    &[
         635  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_EXECUTION_ID,
         636  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_DOCUMENT_NAME,
         637  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_DOCUMENT_VERSION,
         638  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_EXECUTION_STATUS,
         639  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTION_START_TIME,
         640  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTION_END_TIME,
         641  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTED_BY,
         642  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_LOG_FILE,
         643  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS,
         644  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_MODE,
         645  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_PARENT_AUTOMATION_EXECUTION_ID,
         646  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_CURRENT_STEP_NAME,
         647  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_CURRENT_ACTION,
         648  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_FAILURE_MESSAGE,
         649  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_WARNING_MESSAGE,
         650  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_PARAMETER_NAME,
         651  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGETS,
         652  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS,
         653  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_RESOLVED_TARGETS,
         654  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_MAX_CONCURRENCY,
         655  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_MAX_ERRORS,
         656  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET,
         657  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_TYPE,
         658  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_ALARM_CONFIGURATION,
         659  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_TRIGGERED_ALARMS,
         660  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_LOCATIONS_URL,
         661  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_SUBTYPE,
         662  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_SCHEDULED_TIME,
         663  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_RUNBOOKS,
         664  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_OPS_ITEM_ID,
         665  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_ASSOCIATION_ID,
         666  +
        &AUTOMATIONEXECUTIONMETADATA_MEMBER_CHANGE_REQUEST_NAME,
         667  +
    ],
         668  +
);
         669  +
impl AutomationExecutionMetadata {
         670  +
    /// The schema for this shape.
         671  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &AUTOMATIONEXECUTIONMETADATA_SCHEMA;
         672  +
}
         673  +
impl ::aws_smithy_schema::serde::SerializableStruct for AutomationExecutionMetadata {
         674  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         675  +
    fn serialize_members(
         676  +
        &self,
         677  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         678  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         679  +
        if let Some(ref val) = self.automation_execution_id {
         680  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_EXECUTION_ID, val)?;
         681  +
        }
         682  +
        if let Some(ref val) = self.document_name {
         683  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_DOCUMENT_NAME, val)?;
         684  +
        }
         685  +
        if let Some(ref val) = self.document_version {
         686  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_DOCUMENT_VERSION, val)?;
         687  +
        }
         688  +
        if let Some(ref val) = self.automation_execution_status {
         689  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_EXECUTION_STATUS, val.as_str())?;
         690  +
        }
         691  +
        if let Some(ref val) = self.execution_start_time {
         692  +
            ser.write_timestamp(&AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTION_START_TIME, val)?;
         693  +
        }
         694  +
        if let Some(ref val) = self.execution_end_time {
         695  +
            ser.write_timestamp(&AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTION_END_TIME, val)?;
         696  +
        }
         697  +
        if let Some(ref val) = self.executed_by {
         698  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_EXECUTED_BY, val)?;
         699  +
        }
         700  +
        if let Some(ref val) = self.log_file {
         701  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_LOG_FILE, val)?;
         702  +
        }
         703  +
        if let Some(ref val) = self.outputs {
         704  +
            ser.write_map(
         705  +
                &AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS,
         706  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         707  +
                    for (key, value) in val {
         708  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         709  +
         710  +
                        ser.write_list(
         711  +
                            &AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_VALUE,
         712  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         713  +
                                for item in value {
         714  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         715  +
                                }
         716  +
                                Ok(())
         717  +
                            },
         718  +
                        )?;
         719  +
                    }
         720  +
                    Ok(())
         721  +
                },
         722  +
            )?;
         723  +
        }
         724  +
        if let Some(ref val) = self.mode {
         725  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_MODE, val.as_str())?;
         726  +
        }
         727  +
        if let Some(ref val) = self.parent_automation_execution_id {
         728  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_PARENT_AUTOMATION_EXECUTION_ID, val)?;
         729  +
        }
         730  +
        if let Some(ref val) = self.current_step_name {
         731  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_CURRENT_STEP_NAME, val)?;
         732  +
        }
         733  +
        if let Some(ref val) = self.current_action {
         734  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_CURRENT_ACTION, val)?;
         735  +
        }
         736  +
        if let Some(ref val) = self.failure_message {
         737  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_FAILURE_MESSAGE, val)?;
         738  +
        }
         739  +
        if let Some(ref val) = self.warning_message {
         740  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_WARNING_MESSAGE, val)?;
         741  +
        }
         742  +
        if let Some(ref val) = self.target_parameter_name {
         743  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_PARAMETER_NAME, val)?;
         744  +
        }
         745  +
        if let Some(ref val) = self.targets {
         746  +
            ser.write_list(
         747  +
                &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGETS,
         748  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         749  +
                    for item in val {
         750  +
                        ser.write_struct(crate::types::Target::SCHEMA, item)?;
         751  +
                    }
         752  +
                    Ok(())
         753  +
                },
         754  +
            )?;
         755  +
        }
         756  +
        if let Some(ref val) = self.target_maps {
         757  +
            ser.write_list(
         758  +
                &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS,
         759  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         760  +
                    for item in val {
         761  +
                        ser.write_map(
         762  +
                            &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER,
         763  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         764  +
                                for (key, value) in item {
         765  +
                                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         766  +
         767  +
                                    ser.write_list(
         768  +
                                        &AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_VALUE,
         769  +
                                        &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         770  +
                                            for item in value {
         771  +
                                                ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         772  +
                                            }
         773  +
                                            Ok(())
         774  +
                                        },
         775  +
                                    )?;
         776  +
                                }
         777  +
                                Ok(())
         778  +
                            },
         779  +
                        )?;
         780  +
                    }
         781  +
                    Ok(())
         782  +
                },
         783  +
            )?;
         784  +
        }
         785  +
        if let Some(ref val) = self.resolved_targets {
         786  +
            ser.write_struct(&AUTOMATIONEXECUTIONMETADATA_MEMBER_RESOLVED_TARGETS, val)?;
         787  +
        }
         788  +
        if let Some(ref val) = self.max_concurrency {
         789  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_MAX_CONCURRENCY, val)?;
         790  +
        }
         791  +
        if let Some(ref val) = self.max_errors {
         792  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_MAX_ERRORS, val)?;
         793  +
        }
         794  +
        if let Some(ref val) = self.target {
         795  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET, val)?;
         796  +
        }
         797  +
        if let Some(ref val) = self.automation_type {
         798  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_TYPE, val.as_str())?;
         799  +
        }
         800  +
        if let Some(ref val) = self.alarm_configuration {
         801  +
            ser.write_struct(&AUTOMATIONEXECUTIONMETADATA_MEMBER_ALARM_CONFIGURATION, val)?;
         802  +
        }
         803  +
        if let Some(ref val) = self.triggered_alarms {
         804  +
            ser.write_list(
         805  +
                &AUTOMATIONEXECUTIONMETADATA_MEMBER_TRIGGERED_ALARMS,
         806  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         807  +
                    for item in val {
         808  +
                        ser.write_struct(crate::types::AlarmStateInformation::SCHEMA, item)?;
         809  +
                    }
         810  +
                    Ok(())
         811  +
                },
         812  +
            )?;
         813  +
        }
         814  +
        if let Some(ref val) = self.target_locations_url {
         815  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_LOCATIONS_URL, val)?;
         816  +
        }
         817  +
        if let Some(ref val) = self.automation_subtype {
         818  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_AUTOMATION_SUBTYPE, val.as_str())?;
         819  +
        }
         820  +
        if let Some(ref val) = self.scheduled_time {
         821  +
            ser.write_timestamp(&AUTOMATIONEXECUTIONMETADATA_MEMBER_SCHEDULED_TIME, val)?;
         822  +
        }
         823  +
        if let Some(ref val) = self.runbooks {
         824  +
            ser.write_list(
         825  +
                &AUTOMATIONEXECUTIONMETADATA_MEMBER_RUNBOOKS,
         826  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         827  +
                    for item in val {
         828  +
                        ser.write_struct(crate::types::Runbook::SCHEMA, item)?;
         829  +
                    }
         830  +
                    Ok(())
         831  +
                },
         832  +
            )?;
         833  +
        }
         834  +
        if let Some(ref val) = self.ops_item_id {
         835  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_OPS_ITEM_ID, val)?;
         836  +
        }
         837  +
        if let Some(ref val) = self.association_id {
         838  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_ASSOCIATION_ID, val)?;
         839  +
        }
         840  +
        if let Some(ref val) = self.change_request_name {
         841  +
            ser.write_string(&AUTOMATIONEXECUTIONMETADATA_MEMBER_CHANGE_REQUEST_NAME, val)?;
         842  +
        }
         843  +
        Ok(())
         844  +
    }
         845  +
}
         846  +
impl AutomationExecutionMetadata {
         847  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         848  +
    pub fn deserialize(
         849  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         850  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         851  +
        #[allow(unused_variables, unused_mut)]
         852  +
        let mut builder = Self::builder();
         853  +
        #[allow(
         854  +
            unused_variables,
         855  +
            unreachable_code,
         856  +
            clippy::single_match,
         857  +
            clippy::match_single_binding,
         858  +
            clippy::diverging_sub_expression
         859  +
        )]
         860  +
        deserializer.read_struct(&AUTOMATIONEXECUTIONMETADATA_SCHEMA, &mut |member, deser| {
         861  +
            match member.member_index() {
         862  +
                Some(0) => {
         863  +
                    if deser.is_null() {
         864  +
                        deser.read_null()?;
         865  +
                    } else {
         866  +
                        builder.automation_execution_id = Some(deser.read_string(member)?);
         867  +
                    }
         868  +
                }
         869  +
                Some(1) => {
         870  +
                    if deser.is_null() {
         871  +
                        deser.read_null()?;
         872  +
                    } else {
         873  +
                        builder.document_name = Some(deser.read_string(member)?);
         874  +
                    }
         875  +
                }
         876  +
                Some(2) => {
         877  +
                    if deser.is_null() {
         878  +
                        deser.read_null()?;
         879  +
                    } else {
         880  +
                        builder.document_version = Some(deser.read_string(member)?);
         881  +
                    }
         882  +
                }
         883  +
                Some(3) => {
         884  +
                    if deser.is_null() {
         885  +
                        deser.read_null()?;
         886  +
                    } else {
         887  +
                        builder.automation_execution_status =
         888  +
                            Some(crate::types::AutomationExecutionStatus::from(deser.read_string(member)?.as_str()));
         889  +
                    }
         890  +
                }
         891  +
                Some(4) => {
         892  +
                    if deser.is_null() {
         893  +
                        deser.read_null()?;
         894  +
                    } else {
         895  +
                        builder.execution_start_time = Some(deser.read_timestamp(member)?);
         896  +
                    }
         897  +
                }
         898  +
                Some(5) => {
         899  +
                    if deser.is_null() {
         900  +
                        deser.read_null()?;
         901  +
                    } else {
         902  +
                        builder.execution_end_time = Some(deser.read_timestamp(member)?);
         903  +
                    }
         904  +
                }
         905  +
                Some(6) => {
         906  +
                    if deser.is_null() {
         907  +
                        deser.read_null()?;
         908  +
                    } else {
         909  +
                        builder.executed_by = Some(deser.read_string(member)?);
         910  +
                    }
         911  +
                }
         912  +
                Some(7) => {
         913  +
                    if deser.is_null() {
         914  +
                        deser.read_null()?;
         915  +
                    } else {
         916  +
                        builder.log_file = Some(deser.read_string(member)?);
         917  +
                    }
         918  +
                }
         919  +
                Some(8) => {
         920  +
                    if deser.is_null() {
         921  +
                        deser.read_null()?;
         922  +
                    } else {
         923  +
                        builder.outputs = Some({
         924  +
                            let mut container = std::collections::HashMap::new();
         925  +
                            deser.read_map(member, &mut |key, deser| {
         926  +
                                container.insert(key, {
         927  +
                                    let mut list = Vec::new();
         928  +
                                    deser.read_list(&AUTOMATIONEXECUTIONMETADATA_MEMBER_OUTPUTS_VALUE, &mut |deser| {
         929  +
                                        list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
         930  +
                                        Ok(())
         931  +
                                    })?;
         932  +
                                    list
         933  +
                                });
         934  +
                                Ok(())
         935  +
                            })?;
         936  +
                            container
         937  +
                        });
         938  +
                    }
         939  +
                }
         940  +
                Some(9) => {
         941  +
                    if deser.is_null() {
         942  +
                        deser.read_null()?;
         943  +
                    } else {
         944  +
                        builder.mode = Some(crate::types::ExecutionMode::from(deser.read_string(member)?.as_str()));
         945  +
                    }
         946  +
                }
         947  +
                Some(10) => {
         948  +
                    if deser.is_null() {
         949  +
                        deser.read_null()?;
         950  +
                    } else {
         951  +
                        builder.parent_automation_execution_id = Some(deser.read_string(member)?);
         952  +
                    }
         953  +
                }
         954  +
                Some(11) => {
         955  +
                    if deser.is_null() {
         956  +
                        deser.read_null()?;
         957  +
                    } else {
         958  +
                        builder.current_step_name = Some(deser.read_string(member)?);
         959  +
                    }
         960  +
                }
         961  +
                Some(12) => {
         962  +
                    if deser.is_null() {
         963  +
                        deser.read_null()?;
         964  +
                    } else {
         965  +
                        builder.current_action = Some(deser.read_string(member)?);
         966  +
                    }
         967  +
                }
         968  +
                Some(13) => {
         969  +
                    if deser.is_null() {
         970  +
                        deser.read_null()?;
         971  +
                    } else {
         972  +
                        builder.failure_message = Some(deser.read_string(member)?);
         973  +
                    }
         974  +
                }
         975  +
                Some(14) => {
         976  +
                    if deser.is_null() {
         977  +
                        deser.read_null()?;
         978  +
                    } else {
         979  +
                        builder.warning_message = Some(deser.read_string(member)?);
         980  +
                    }
         981  +
                }
         982  +
                Some(15) => {
         983  +
                    if deser.is_null() {
         984  +
                        deser.read_null()?;
         985  +
                    } else {
         986  +
                        builder.target_parameter_name = Some(deser.read_string(member)?);
         987  +
                    }
         988  +
                }
         989  +
                Some(16) => {
         990  +
                    if deser.is_null() {
         991  +
                        deser.read_null()?;
         992  +
                    } else {
         993  +
                        builder.targets = Some({
         994  +
                            let mut container = Vec::new();
         995  +
                            deser.read_list(member, &mut |deser| {
         996  +
                                container.push(crate::types::Target::deserialize(deser)?);
         997  +
                                Ok(())
         998  +
                            })?;
         999  +
                            container
        1000  +
                        });
        1001  +
                    }
        1002  +
                }
        1003  +
                Some(17) => {
        1004  +
                    if deser.is_null() {
        1005  +
                        deser.read_null()?;
        1006  +
                    } else {
        1007  +
                        builder.target_maps = Some({
        1008  +
                            let mut container = Vec::new();
        1009  +
                            deser.read_list(member, &mut |deser| {
        1010  +
                                container.push({
        1011  +
                                    let mut map = ::std::collections::HashMap::new();
        1012  +
                                    deser.read_map(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER, &mut |key, deser| {
        1013  +
                                        let value = {
        1014  +
                                            let mut list = Vec::new();
        1015  +
                                            deser.read_list(&AUTOMATIONEXECUTIONMETADATA_MEMBER_TARGET_MAPS_MEMBER_VALUE, &mut |deser| {
        1016  +
                                                list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
        1017  +
                                                Ok(())
        1018  +
                                            })?;
        1019  +
                                            list
        1020  +
                                        };
        1021  +
                                        map.insert(key, value);
        1022  +
                                        Ok(())
        1023  +
                                    })?;
        1024  +
                                    map
        1025  +
                                });
        1026  +
                                Ok(())
        1027  +
                            })?;
        1028  +
                            container
        1029  +
                        });
        1030  +
                    }
        1031  +
                }
        1032  +
                Some(18) => {
        1033  +
                    if deser.is_null() {
        1034  +
                        deser.read_null()?;
        1035  +
                    } else {
        1036  +
                        builder.resolved_targets = Some(crate::types::ResolvedTargets::deserialize(deser)?);
        1037  +
                    }
        1038  +
                }
        1039  +
                Some(19) => {
        1040  +
                    if deser.is_null() {
        1041  +
                        deser.read_null()?;
        1042  +
                    } else {
        1043  +
                        builder.max_concurrency = Some(deser.read_string(member)?);
        1044  +
                    }
        1045  +
                }
        1046  +
                Some(20) => {
        1047  +
                    if deser.is_null() {
        1048  +
                        deser.read_null()?;
        1049  +
                    } else {
        1050  +
                        builder.max_errors = Some(deser.read_string(member)?);
        1051  +
                    }
        1052  +
                }
        1053  +
                Some(21) => {
        1054  +
                    if deser.is_null() {
        1055  +
                        deser.read_null()?;
        1056  +
                    } else {
        1057  +
                        builder.target = Some(deser.read_string(member)?);
        1058  +
                    }
        1059  +
                }
        1060  +
                Some(22) => {
        1061  +
                    if deser.is_null() {
        1062  +
                        deser.read_null()?;
        1063  +
                    } else {
        1064  +
                        builder.automation_type = Some(crate::types::AutomationType::from(deser.read_string(member)?.as_str()));
        1065  +
                    }
        1066  +
                }
        1067  +
                Some(23) => {
        1068  +
                    if deser.is_null() {
        1069  +
                        deser.read_null()?;
        1070  +
                    } else {
        1071  +
                        builder.alarm_configuration = Some(crate::types::AlarmConfiguration::deserialize(deser)?);
        1072  +
                    }
        1073  +
                }
        1074  +
                Some(24) => {
        1075  +
                    if deser.is_null() {
        1076  +
                        deser.read_null()?;
        1077  +
                    } else {
        1078  +
                        builder.triggered_alarms = Some({
        1079  +
                            let mut container = Vec::new();
        1080  +
                            deser.read_list(member, &mut |deser| {
        1081  +
                                container.push(crate::types::AlarmStateInformation::deserialize(deser)?);
        1082  +
                                Ok(())
        1083  +
                            })?;
        1084  +
                            container
        1085  +
                        });
        1086  +
                    }
        1087  +
                }
        1088  +
                Some(25) => {
        1089  +
                    if deser.is_null() {
        1090  +
                        deser.read_null()?;
        1091  +
                    } else {
        1092  +
                        builder.target_locations_url = Some(deser.read_string(member)?);
        1093  +
                    }
        1094  +
                }
        1095  +
                Some(26) => {
        1096  +
                    if deser.is_null() {
        1097  +
                        deser.read_null()?;
        1098  +
                    } else {
        1099  +
                        builder.automation_subtype = Some(crate::types::AutomationSubtype::from(deser.read_string(member)?.as_str()));
        1100  +
                    }
        1101  +
                }
        1102  +
                Some(27) => {
        1103  +
                    if deser.is_null() {
        1104  +
                        deser.read_null()?;
        1105  +
                    } else {
        1106  +
                        builder.scheduled_time = Some(deser.read_timestamp(member)?);
        1107  +
                    }
        1108  +
                }
        1109  +
                Some(28) => {
        1110  +
                    if deser.is_null() {
        1111  +
                        deser.read_null()?;
        1112  +
                    } else {
        1113  +
                        builder.runbooks = Some({
        1114  +
                            let mut container = Vec::new();
        1115  +
                            deser.read_list(member, &mut |deser| {
        1116  +
                                container.push(crate::types::Runbook::deserialize(deser)?);
        1117  +
                                Ok(())
        1118  +
                            })?;
        1119  +
                            container
        1120  +
                        });
        1121  +
                    }
        1122  +
                }
        1123  +
                Some(29) => {
        1124  +
                    if deser.is_null() {
        1125  +
                        deser.read_null()?;
        1126  +
                    } else {
        1127  +
                        builder.ops_item_id = Some(deser.read_string(member)?);
        1128  +
                    }
        1129  +
                }
        1130  +
                Some(30) => {
        1131  +
                    if deser.is_null() {
        1132  +
                        deser.read_null()?;
        1133  +
                    } else {
        1134  +
                        builder.association_id = Some(deser.read_string(member)?);
        1135  +
                    }
        1136  +
                }
        1137  +
                Some(31) => {
        1138  +
                    if deser.is_null() {
        1139  +
                        deser.read_null()?;
        1140  +
                    } else {
        1141  +
                        builder.change_request_name = Some(deser.read_string(member)?);
        1142  +
                    }
        1143  +
                }
        1144  +
                _ => {}
        1145  +
            }
        1146  +
            Ok(())
        1147  +
        })?;
        1148  +
        Ok(builder.build())
        1149  +
    }
        1150  +
}
        1151  +
impl AutomationExecutionMetadata {
        1152  +
    /// Deserializes this structure from a body deserializer and HTTP response.
        1153  +
    pub fn deserialize_with_response(
        1154  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1155  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
        1156  +
        _status: u16,
        1157  +
        _body: &[u8],
        1158  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1159  +
        Self::deserialize(deserializer)
        1160  +
    }
        1161  +
}
        1162  +
impl AutomationExecutionMetadata {
        1163  +
    /// Creates a new builder-style object to manufacture [`AutomationExecutionMetadata`](crate::types::AutomationExecutionMetadata).
        1164  +
    pub fn builder() -> crate::types::builders::AutomationExecutionMetadataBuilder {
        1165  +
        crate::types::builders::AutomationExecutionMetadataBuilder::default()
        1166  +
    }
        1167  +
}
        1168  +
        1169  +
/// A builder for [`AutomationExecutionMetadata`](crate::types::AutomationExecutionMetadata).
        1170  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
        1171  +
#[non_exhaustive]
        1172  +
pub struct AutomationExecutionMetadataBuilder {
        1173  +
    pub(crate) automation_execution_id: ::std::option::Option<::std::string::String>,
        1174  +
    pub(crate) document_name: ::std::option::Option<::std::string::String>,
        1175  +
    pub(crate) document_version: ::std::option::Option<::std::string::String>,
        1176  +
    pub(crate) automation_execution_status: ::std::option::Option<crate::types::AutomationExecutionStatus>,
        1177  +
    pub(crate) execution_start_time: ::std::option::Option<::aws_smithy_types::DateTime>,
        1178  +
    pub(crate) execution_end_time: ::std::option::Option<::aws_smithy_types::DateTime>,
        1179  +
    pub(crate) executed_by: ::std::option::Option<::std::string::String>,
        1180  +
    pub(crate) log_file: ::std::option::Option<::std::string::String>,
        1181  +
    pub(crate) outputs: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
        1182  +
    pub(crate) mode: ::std::option::Option<crate::types::ExecutionMode>,
        1183  +
    pub(crate) parent_automation_execution_id: ::std::option::Option<::std::string::String>,
        1184  +
    pub(crate) current_step_name: ::std::option::Option<::std::string::String>,
        1185  +
    pub(crate) current_action: ::std::option::Option<::std::string::String>,
        1186  +
    pub(crate) failure_message: ::std::option::Option<::std::string::String>,
        1187  +
    pub(crate) warning_message: ::std::option::Option<::std::string::String>,
        1188  +
    pub(crate) target_parameter_name: ::std::option::Option<::std::string::String>,
        1189  +
    pub(crate) targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
        1190  +
    pub(crate) target_maps:
        1191  +
        ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
        1192  +
    pub(crate) resolved_targets: ::std::option::Option<crate::types::ResolvedTargets>,
        1193  +
    pub(crate) max_concurrency: ::std::option::Option<::std::string::String>,
        1194  +
    pub(crate) max_errors: ::std::option::Option<::std::string::String>,
        1195  +
    pub(crate) target: ::std::option::Option<::std::string::String>,
        1196  +
    pub(crate) automation_type: ::std::option::Option<crate::types::AutomationType>,
        1197  +
    pub(crate) alarm_configuration: ::std::option::Option<crate::types::AlarmConfiguration>,
        1198  +
    pub(crate) triggered_alarms: ::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>>,
        1199  +
    pub(crate) target_locations_url: ::std::option::Option<::std::string::String>,
        1200  +
    pub(crate) automation_subtype: ::std::option::Option<crate::types::AutomationSubtype>,
        1201  +
    pub(crate) scheduled_time: ::std::option::Option<::aws_smithy_types::DateTime>,
        1202  +
    pub(crate) runbooks: ::std::option::Option<::std::vec::Vec<crate::types::Runbook>>,
        1203  +
    pub(crate) ops_item_id: ::std::option::Option<::std::string::String>,
        1204  +
    pub(crate) association_id: ::std::option::Option<::std::string::String>,
        1205  +
    pub(crate) change_request_name: ::std::option::Option<::std::string::String>,
        1206  +
}
        1207  +
impl AutomationExecutionMetadataBuilder {
        1208  +
    /// <p>The execution ID.</p>
        1209  +
    pub fn automation_execution_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1210  +
        self.automation_execution_id = ::std::option::Option::Some(input.into());
        1211  +
        self
        1212  +
    }
        1213  +
    /// <p>The execution ID.</p>
        1214  +
    pub fn set_automation_execution_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1215  +
        self.automation_execution_id = input;
        1216  +
        self
        1217  +
    }
        1218  +
    /// <p>The execution ID.</p>
        1219  +
    pub fn get_automation_execution_id(&self) -> &::std::option::Option<::std::string::String> {
        1220  +
        &self.automation_execution_id
        1221  +
    }
        1222  +
    /// <p>The name of the Automation runbook used during execution.</p>
        1223  +
    pub fn document_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1224  +
        self.document_name = ::std::option::Option::Some(input.into());
        1225  +
        self
        1226  +
    }
        1227  +
    /// <p>The name of the Automation runbook used during execution.</p>
        1228  +
    pub fn set_document_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1229  +
        self.document_name = input;
        1230  +
        self
        1231  +
    }
        1232  +
    /// <p>The name of the Automation runbook used during execution.</p>
        1233  +
    pub fn get_document_name(&self) -> &::std::option::Option<::std::string::String> {
        1234  +
        &self.document_name
        1235  +
    }
        1236  +
    /// <p>The document version used during the execution.</p>
        1237  +
    pub fn document_version(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1238  +
        self.document_version = ::std::option::Option::Some(input.into());
        1239  +
        self
        1240  +
    }
        1241  +
    /// <p>The document version used during the execution.</p>
        1242  +
    pub fn set_document_version(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1243  +
        self.document_version = input;
        1244  +
        self
        1245  +
    }
        1246  +
    /// <p>The document version used during the execution.</p>
        1247  +
    pub fn get_document_version(&self) -> &::std::option::Option<::std::string::String> {
        1248  +
        &self.document_version
        1249  +
    }
        1250  +
    /// <p>The status of the execution.</p>
        1251  +
    pub fn automation_execution_status(mut self, input: crate::types::AutomationExecutionStatus) -> Self {
        1252  +
        self.automation_execution_status = ::std::option::Option::Some(input);
        1253  +
        self
        1254  +
    }
        1255  +
    /// <p>The status of the execution.</p>
        1256  +
    pub fn set_automation_execution_status(mut self, input: ::std::option::Option<crate::types::AutomationExecutionStatus>) -> Self {
        1257  +
        self.automation_execution_status = input;
        1258  +
        self
        1259  +
    }
        1260  +
    /// <p>The status of the execution.</p>
        1261  +
    pub fn get_automation_execution_status(&self) -> &::std::option::Option<crate::types::AutomationExecutionStatus> {
        1262  +
        &self.automation_execution_status
        1263  +
    }
        1264  +
    /// <p>The time the execution started.</p>
        1265  +
    pub fn execution_start_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
        1266  +
        self.execution_start_time = ::std::option::Option::Some(input);
        1267  +
        self
        1268  +
    }
        1269  +
    /// <p>The time the execution started.</p>
        1270  +
    pub fn set_execution_start_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
        1271  +
        self.execution_start_time = input;
        1272  +
        self
        1273  +
    }
        1274  +
    /// <p>The time the execution started.</p>
        1275  +
    pub fn get_execution_start_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
        1276  +
        &self.execution_start_time
        1277  +
    }
        1278  +
    /// <p>The time the execution finished. This isn't populated if the execution is still in progress.</p>
        1279  +
    pub fn execution_end_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
        1280  +
        self.execution_end_time = ::std::option::Option::Some(input);
        1281  +
        self
        1282  +
    }
        1283  +
    /// <p>The time the execution finished. This isn't populated if the execution is still in progress.</p>
        1284  +
    pub fn set_execution_end_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
        1285  +
        self.execution_end_time = input;
        1286  +
        self
        1287  +
    }
        1288  +
    /// <p>The time the execution finished. This isn't populated if the execution is still in progress.</p>
        1289  +
    pub fn get_execution_end_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
        1290  +
        &self.execution_end_time
        1291  +
    }
        1292  +
    /// <p>The IAM role ARN of the user who ran the automation.</p>
        1293  +
    pub fn executed_by(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1294  +
        self.executed_by = ::std::option::Option::Some(input.into());
        1295  +
        self
        1296  +
    }
        1297  +
    /// <p>The IAM role ARN of the user who ran the automation.</p>
        1298  +
    pub fn set_executed_by(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1299  +
        self.executed_by = input;
        1300  +
        self
        1301  +
    }
        1302  +
    /// <p>The IAM role ARN of the user who ran the automation.</p>
        1303  +
    pub fn get_executed_by(&self) -> &::std::option::Option<::std::string::String> {
        1304  +
        &self.executed_by
        1305  +
    }
        1306  +
    /// <p>An S3 bucket where execution information is stored.</p>
        1307  +
    pub fn log_file(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1308  +
        self.log_file = ::std::option::Option::Some(input.into());
        1309  +
        self
        1310  +
    }
        1311  +
    /// <p>An S3 bucket where execution information is stored.</p>
        1312  +
    pub fn set_log_file(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1313  +
        self.log_file = input;
        1314  +
        self
        1315  +
    }
        1316  +
    /// <p>An S3 bucket where execution information is stored.</p>
        1317  +
    pub fn get_log_file(&self) -> &::std::option::Option<::std::string::String> {
        1318  +
        &self.log_file
        1319  +
    }
        1320  +
    /// Adds a key-value pair to `outputs`.
        1321  +
    ///
        1322  +
    /// To override the contents of this collection use [`set_outputs`](Self::set_outputs).
        1323  +
    ///
        1324  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1325  +
    pub fn outputs(mut self, k: impl ::std::convert::Into<::std::string::String>, v: ::std::vec::Vec<::std::string::String>) -> Self {
        1326  +
        let mut hash_map = self.outputs.unwrap_or_default();
        1327  +
        hash_map.insert(k.into(), v);
        1328  +
        self.outputs = ::std::option::Option::Some(hash_map);
        1329  +
        self
        1330  +
    }
        1331  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1332  +
    pub fn set_outputs(
        1333  +
        mut self,
        1334  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
        1335  +
    ) -> Self {
        1336  +
        self.outputs = input;
        1337  +
        self
        1338  +
    }
        1339  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1340  +
    pub fn get_outputs(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
        1341  +
        &self.outputs
        1342  +
    }
        1343  +
    /// <p>The Automation execution mode.</p>
        1344  +
    pub fn mode(mut self, input: crate::types::ExecutionMode) -> Self {
        1345  +
        self.mode = ::std::option::Option::Some(input);
        1346  +
        self
        1347  +
    }
        1348  +
    /// <p>The Automation execution mode.</p>
        1349  +
    pub fn set_mode(mut self, input: ::std::option::Option<crate::types::ExecutionMode>) -> Self {
        1350  +
        self.mode = input;
        1351  +
        self
        1352  +
    }
        1353  +
    /// <p>The Automation execution mode.</p>
        1354  +
    pub fn get_mode(&self) -> &::std::option::Option<crate::types::ExecutionMode> {
        1355  +
        &self.mode
        1356  +
    }
        1357  +
    /// <p>The execution ID of the parent automation.</p>
        1358  +
    pub fn parent_automation_execution_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1359  +
        self.parent_automation_execution_id = ::std::option::Option::Some(input.into());
        1360  +
        self
        1361  +
    }
        1362  +
    /// <p>The execution ID of the parent automation.</p>
        1363  +
    pub fn set_parent_automation_execution_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1364  +
        self.parent_automation_execution_id = input;
        1365  +
        self
        1366  +
    }
        1367  +
    /// <p>The execution ID of the parent automation.</p>
        1368  +
    pub fn get_parent_automation_execution_id(&self) -> &::std::option::Option<::std::string::String> {
        1369  +
        &self.parent_automation_execution_id
        1370  +
    }
        1371  +
    /// <p>The name of the step that is currently running.</p>
        1372  +
    pub fn current_step_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1373  +
        self.current_step_name = ::std::option::Option::Some(input.into());
        1374  +
        self
        1375  +
    }
        1376  +
    /// <p>The name of the step that is currently running.</p>
        1377  +
    pub fn set_current_step_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1378  +
        self.current_step_name = input;
        1379  +
        self
        1380  +
    }
        1381  +
    /// <p>The name of the step that is currently running.</p>
        1382  +
    pub fn get_current_step_name(&self) -> &::std::option::Option<::std::string::String> {
        1383  +
        &self.current_step_name
        1384  +
    }
        1385  +
    /// <p>The action of the step that is currently running.</p>
        1386  +
    pub fn current_action(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1387  +
        self.current_action = ::std::option::Option::Some(input.into());
        1388  +
        self
        1389  +
    }
        1390  +
    /// <p>The action of the step that is currently running.</p>
        1391  +
    pub fn set_current_action(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1392  +
        self.current_action = input;
        1393  +
        self
        1394  +
    }
        1395  +
    /// <p>The action of the step that is currently running.</p>
        1396  +
    pub fn get_current_action(&self) -> &::std::option::Option<::std::string::String> {
        1397  +
        &self.current_action
        1398  +
    }
        1399  +
    /// <p>A message that describes a failure that occurred during the automation execution.</p>
        1400  +
    pub fn failure_message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1401  +
        self.failure_message = ::std::option::Option::Some(input.into());
        1402  +
        self
        1403  +
    }
        1404  +
    /// <p>A message that describes a failure that occurred during the automation execution.</p>
        1405  +
    pub fn set_failure_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1406  +
        self.failure_message = input;
        1407  +
        self
        1408  +
    }
        1409  +
    /// <p>A message that describes a failure that occurred during the automation execution.</p>
        1410  +
    pub fn get_failure_message(&self) -> &::std::option::Option<::std::string::String> {
        1411  +
        &self.failure_message
        1412  +
    }
        1413  +
    /// <p>A message that describes a non-critical issue that occurred during the automation execution.</p>
        1414  +
    pub fn warning_message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1415  +
        self.warning_message = ::std::option::Option::Some(input.into());
        1416  +
        self
        1417  +
    }
        1418  +
    /// <p>A message that describes a non-critical issue that occurred during the automation execution.</p>
        1419  +
    pub fn set_warning_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1420  +
        self.warning_message = input;
        1421  +
        self
        1422  +
    }
        1423  +
    /// <p>A message that describes a non-critical issue that occurred during the automation execution.</p>
        1424  +
    pub fn get_warning_message(&self) -> &::std::option::Option<::std::string::String> {
        1425  +
        &self.warning_message
        1426  +
    }
        1427  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1428  +
    pub fn target_parameter_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1429  +
        self.target_parameter_name = ::std::option::Option::Some(input.into());
        1430  +
        self
        1431  +
    }
        1432  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1433  +
    pub fn set_target_parameter_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1434  +
        self.target_parameter_name = input;
        1435  +
        self
        1436  +
    }
        1437  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1438  +
    pub fn get_target_parameter_name(&self) -> &::std::option::Option<::std::string::String> {
        1439  +
        &self.target_parameter_name
        1440  +
    }
        1441  +
    /// Appends an item to `targets`.
        1442  +
    ///
        1443  +
    /// To override the contents of this collection use [`set_targets`](Self::set_targets).
        1444  +
    ///
        1445  +
    /// <p>The targets defined by the user when starting the automation.</p>
        1446  +
    pub fn targets(mut self, input: crate::types::Target) -> Self {
        1447  +
        let mut v = self.targets.unwrap_or_default();
        1448  +
        v.push(input);
        1449  +
        self.targets = ::std::option::Option::Some(v);
        1450  +
        self
        1451  +
    }
        1452  +
    /// <p>The targets defined by the user when starting the automation.</p>
        1453  +
    pub fn set_targets(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Target>>) -> Self {
        1454  +
        self.targets = input;
        1455  +
        self
        1456  +
    }
        1457  +
    /// <p>The targets defined by the user when starting the automation.</p>
        1458  +
    pub fn get_targets(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Target>> {
        1459  +
        &self.targets
        1460  +
    }
        1461  +
    /// Appends an item to `target_maps`.
        1462  +
    ///
        1463  +
    /// To override the contents of this collection use [`set_target_maps`](Self::set_target_maps).
        1464  +
    ///
        1465  +
    /// <p>The specified key-value mapping of document parameters to target resources.</p>
        1466  +
    pub fn target_maps(mut self, input: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>) -> Self {
        1467  +
        let mut v = self.target_maps.unwrap_or_default();
        1468  +
        v.push(input);
        1469  +
        self.target_maps = ::std::option::Option::Some(v);
        1470  +
        self
        1471  +
    }
        1472  +
    /// <p>The specified key-value mapping of document parameters to target resources.</p>
        1473  +
    pub fn set_target_maps(
        1474  +
        mut self,
        1475  +
        input: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
        1476  +
    ) -> Self {
        1477  +
        self.target_maps = input;
        1478  +
        self
        1479  +
    }
        1480  +
    /// <p>The specified key-value mapping of document parameters to target resources.</p>
        1481  +
    pub fn get_target_maps(
        1482  +
        &self,
        1483  +
    ) -> &::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>> {
        1484  +
        &self.target_maps
        1485  +
    }
        1486  +
    /// <p>A list of targets that resolved during the execution.</p>
        1487  +
    pub fn resolved_targets(mut self, input: crate::types::ResolvedTargets) -> Self {
        1488  +
        self.resolved_targets = ::std::option::Option::Some(input);
        1489  +
        self
        1490  +
    }
        1491  +
    /// <p>A list of targets that resolved during the execution.</p>
        1492  +
    pub fn set_resolved_targets(mut self, input: ::std::option::Option<crate::types::ResolvedTargets>) -> Self {
        1493  +
        self.resolved_targets = input;
        1494  +
        self
        1495  +
    }
        1496  +
    /// <p>A list of targets that resolved during the execution.</p>
        1497  +
    pub fn get_resolved_targets(&self) -> &::std::option::Option<crate::types::ResolvedTargets> {
        1498  +
        &self.resolved_targets
        1499  +
    }
        1500  +
    /// <p>The <code>MaxConcurrency</code> value specified by the user when starting the automation.</p>
        1501  +
    pub fn max_concurrency(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1502  +
        self.max_concurrency = ::std::option::Option::Some(input.into());
        1503  +
        self
        1504  +
    }
        1505  +
    /// <p>The <code>MaxConcurrency</code> value specified by the user when starting the automation.</p>
        1506  +
    pub fn set_max_concurrency(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1507  +
        self.max_concurrency = input;
        1508  +
        self
        1509  +
    }
        1510  +
    /// <p>The <code>MaxConcurrency</code> value specified by the user when starting the automation.</p>
        1511  +
    pub fn get_max_concurrency(&self) -> &::std::option::Option<::std::string::String> {
        1512  +
        &self.max_concurrency
        1513  +
    }
        1514  +
    /// <p>The <code>MaxErrors</code> value specified by the user when starting the automation.</p>
        1515  +
    pub fn max_errors(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1516  +
        self.max_errors = ::std::option::Option::Some(input.into());
        1517  +
        self
        1518  +
    }
        1519  +
    /// <p>The <code>MaxErrors</code> value specified by the user when starting the automation.</p>
        1520  +
    pub fn set_max_errors(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1521  +
        self.max_errors = input;
        1522  +
        self
        1523  +
    }
        1524  +
    /// <p>The <code>MaxErrors</code> value specified by the user when starting the automation.</p>
        1525  +
    pub fn get_max_errors(&self) -> &::std::option::Option<::std::string::String> {
        1526  +
        &self.max_errors
        1527  +
    }
        1528  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1529  +
    pub fn target(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1530  +
        self.target = ::std::option::Option::Some(input.into());
        1531  +
        self
        1532  +
    }
        1533  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1534  +
    pub fn set_target(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1535  +
        self.target = input;
        1536  +
        self
        1537  +
    }
        1538  +
    /// <p>The list of execution outputs as defined in the Automation runbook.</p>
        1539  +
    pub fn get_target(&self) -> &::std::option::Option<::std::string::String> {
        1540  +
        &self.target
        1541  +
    }
        1542  +
    /// <p>Use this filter with <code>DescribeAutomationExecutions</code>. Specify either Local or CrossAccount. CrossAccount is an Automation that runs in multiple Amazon Web Services Regions and Amazon Web Services accounts. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation-multiple-accounts-and-regions.html">Running automations in multiple Amazon Web Services Regions and accounts</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1543  +
    pub fn automation_type(mut self, input: crate::types::AutomationType) -> Self {
        1544  +
        self.automation_type = ::std::option::Option::Some(input);
        1545  +
        self
        1546  +
    }
        1547  +
    /// <p>Use this filter with <code>DescribeAutomationExecutions</code>. Specify either Local or CrossAccount. CrossAccount is an Automation that runs in multiple Amazon Web Services Regions and Amazon Web Services accounts. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation-multiple-accounts-and-regions.html">Running automations in multiple Amazon Web Services Regions and accounts</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1548  +
    pub fn set_automation_type(mut self, input: ::std::option::Option<crate::types::AutomationType>) -> Self {
        1549  +
        self.automation_type = input;
        1550  +
        self
        1551  +
    }
        1552  +
    /// <p>Use this filter with <code>DescribeAutomationExecutions</code>. Specify either Local or CrossAccount. CrossAccount is an Automation that runs in multiple Amazon Web Services Regions and Amazon Web Services accounts. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation-multiple-accounts-and-regions.html">Running automations in multiple Amazon Web Services Regions and accounts</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1553  +
    pub fn get_automation_type(&self) -> &::std::option::Option<crate::types::AutomationType> {
        1554  +
        &self.automation_type
        1555  +
    }
        1556  +
    /// <p>The details for the CloudWatch alarm applied to your automation.</p>
        1557  +
    pub fn alarm_configuration(mut self, input: crate::types::AlarmConfiguration) -> Self {
        1558  +
        self.alarm_configuration = ::std::option::Option::Some(input);
        1559  +
        self
        1560  +
    }
        1561  +
    /// <p>The details for the CloudWatch alarm applied to your automation.</p>
        1562  +
    pub fn set_alarm_configuration(mut self, input: ::std::option::Option<crate::types::AlarmConfiguration>) -> Self {
        1563  +
        self.alarm_configuration = input;
        1564  +
        self
        1565  +
    }
        1566  +
    /// <p>The details for the CloudWatch alarm applied to your automation.</p>
        1567  +
    pub fn get_alarm_configuration(&self) -> &::std::option::Option<crate::types::AlarmConfiguration> {
        1568  +
        &self.alarm_configuration
        1569  +
    }
        1570  +
    /// Appends an item to `triggered_alarms`.
        1571  +
    ///
        1572  +
    /// To override the contents of this collection use [`set_triggered_alarms`](Self::set_triggered_alarms).
        1573  +
    ///
        1574  +
    /// <p>The CloudWatch alarm that was invoked by the automation.</p>
        1575  +
    pub fn triggered_alarms(mut self, input: crate::types::AlarmStateInformation) -> Self {
        1576  +
        let mut v = self.triggered_alarms.unwrap_or_default();
        1577  +
        v.push(input);
        1578  +
        self.triggered_alarms = ::std::option::Option::Some(v);
        1579  +
        self
        1580  +
    }
        1581  +
    /// <p>The CloudWatch alarm that was invoked by the automation.</p>
        1582  +
    pub fn set_triggered_alarms(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>>) -> Self {
        1583  +
        self.triggered_alarms = input;
        1584  +
        self
        1585  +
    }
        1586  +
    /// <p>The CloudWatch alarm that was invoked by the automation.</p>
        1587  +
    pub fn get_triggered_alarms(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::AlarmStateInformation>> {
        1588  +
        &self.triggered_alarms
        1589  +
    }
        1590  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported</p>
        1591  +
    pub fn target_locations_url(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1592  +
        self.target_locations_url = ::std::option::Option::Some(input.into());
        1593  +
        self
        1594  +
    }
        1595  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported</p>
        1596  +
    pub fn set_target_locations_url(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1597  +
        self.target_locations_url = input;
        1598  +
        self
        1599  +
    }
        1600  +
    /// <p>A publicly accessible URL for a file that contains the <code>TargetLocations</code> body. Currently, only files in presigned Amazon S3 buckets are supported</p>
        1601  +
    pub fn get_target_locations_url(&self) -> &::std::option::Option<::std::string::String> {
        1602  +
        &self.target_locations_url
        1603  +
    }
        1604  +
    /// <p>The subtype of the Automation operation. Currently, the only supported value is <code>ChangeRequest</code>.</p>
        1605  +
    pub fn automation_subtype(mut self, input: crate::types::AutomationSubtype) -> Self {
        1606  +
        self.automation_subtype = ::std::option::Option::Some(input);
        1607  +
        self
        1608  +
    }
        1609  +
    /// <p>The subtype of the Automation operation. Currently, the only supported value is <code>ChangeRequest</code>.</p>
        1610  +
    pub fn set_automation_subtype(mut self, input: ::std::option::Option<crate::types::AutomationSubtype>) -> Self {
        1611  +
        self.automation_subtype = input;
        1612  +
        self
        1613  +
    }
        1614  +
    /// <p>The subtype of the Automation operation. Currently, the only supported value is <code>ChangeRequest</code>.</p>
        1615  +
    pub fn get_automation_subtype(&self) -> &::std::option::Option<crate::types::AutomationSubtype> {
        1616  +
        &self.automation_subtype
        1617  +
    }
        1618  +
    /// <p>The date and time the Automation operation is scheduled to start.</p>
        1619  +
    pub fn scheduled_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
        1620  +
        self.scheduled_time = ::std::option::Option::Some(input);
        1621  +
        self
        1622  +
    }
        1623  +
    /// <p>The date and time the Automation operation is scheduled to start.</p>
        1624  +
    pub fn set_scheduled_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
        1625  +
        self.scheduled_time = input;
        1626  +
        self
        1627  +
    }
        1628  +
    /// <p>The date and time the Automation operation is scheduled to start.</p>
        1629  +
    pub fn get_scheduled_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
        1630  +
        &self.scheduled_time
        1631  +
    }
        1632  +
    /// Appends an item to `runbooks`.
        1633  +
    ///
        1634  +
    /// To override the contents of this collection use [`set_runbooks`](Self::set_runbooks).
        1635  +
    ///
        1636  +
    /// <p>Information about the Automation runbooks that are run during a runbook workflow in Change Manager.</p><note>
        1637  +
    /// <p>The Automation runbooks specified for the runbook workflow can't run until all required approvals for the change request have been received.</p>
        1638  +
    /// </note>
        1639  +
    pub fn runbooks(mut self, input: crate::types::Runbook) -> Self {
        1640  +
        let mut v = self.runbooks.unwrap_or_default();
        1641  +
        v.push(input);
        1642  +
        self.runbooks = ::std::option::Option::Some(v);
        1643  +
        self
        1644  +
    }
        1645  +
    /// <p>Information about the Automation runbooks that are run during a runbook workflow in Change Manager.</p><note>
        1646  +
    /// <p>The Automation runbooks specified for the runbook workflow can't run until all required approvals for the change request have been received.</p>
        1647  +
    /// </note>
        1648  +
    pub fn set_runbooks(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Runbook>>) -> Self {
        1649  +
        self.runbooks = input;
        1650  +
        self
        1651  +
    }
        1652  +
    /// <p>Information about the Automation runbooks that are run during a runbook workflow in Change Manager.</p><note>
        1653  +
    /// <p>The Automation runbooks specified for the runbook workflow can't run until all required approvals for the change request have been received.</p>
        1654  +
    /// </note>
        1655  +
    pub fn get_runbooks(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Runbook>> {
        1656  +
        &self.runbooks
        1657  +
    }
        1658  +
    /// <p>The ID of an OpsItem that is created to represent a Change Manager change request.</p>
        1659  +
    pub fn ops_item_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1660  +
        self.ops_item_id = ::std::option::Option::Some(input.into());
        1661  +
        self
        1662  +
    }
        1663  +
    /// <p>The ID of an OpsItem that is created to represent a Change Manager change request.</p>
        1664  +
    pub fn set_ops_item_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1665  +
        self.ops_item_id = input;
        1666  +
        self
        1667  +
    }
        1668  +
    /// <p>The ID of an OpsItem that is created to represent a Change Manager change request.</p>
        1669  +
    pub fn get_ops_item_id(&self) -> &::std::option::Option<::std::string::String> {
        1670  +
        &self.ops_item_id
        1671  +
    }
        1672  +
    /// <p>The ID of a State Manager association used in the Automation operation.</p>
        1673  +
    pub fn association_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1674  +
        self.association_id = ::std::option::Option::Some(input.into());
        1675  +
        self
        1676  +
    }
        1677  +
    /// <p>The ID of a State Manager association used in the Automation operation.</p>
        1678  +
    pub fn set_association_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1679  +
        self.association_id = input;
        1680  +
        self
        1681  +
    }
        1682  +
    /// <p>The ID of a State Manager association used in the Automation operation.</p>
        1683  +
    pub fn get_association_id(&self) -> &::std::option::Option<::std::string::String> {
        1684  +
        &self.association_id
        1685  +
    }
        1686  +
    /// <p>The name of the Change Manager change request.</p>
        1687  +
    pub fn change_request_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1688  +
        self.change_request_name = ::std::option::Option::Some(input.into());
        1689  +
        self
        1690  +
    }
        1691  +
    /// <p>The name of the Change Manager change request.</p>
        1692  +
    pub fn set_change_request_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1693  +
        self.change_request_name = input;
        1694  +
        self
        1695  +
    }
        1696  +
    /// <p>The name of the Change Manager change request.</p>
        1697  +
    pub fn get_change_request_name(&self) -> &::std::option::Option<::std::string::String> {
        1698  +
        &self.change_request_name
        1699  +
    }
        1700  +
    /// Consumes the builder and constructs a [`AutomationExecutionMetadata`](crate::types::AutomationExecutionMetadata).
        1701  +
    pub fn build(self) -> crate::types::AutomationExecutionMetadata {
        1702  +
        crate::types::AutomationExecutionMetadata {
        1703  +
            automation_execution_id: self.automation_execution_id,
        1704  +
            document_name: self.document_name,
        1705  +
            document_version: self.document_version,
        1706  +
            automation_execution_status: self.automation_execution_status,
        1707  +
            execution_start_time: self.execution_start_time,
        1708  +
            execution_end_time: self.execution_end_time,
        1709  +
            executed_by: self.executed_by,
        1710  +
            log_file: self.log_file,
        1711  +
            outputs: self.outputs,
        1712  +
            mode: self.mode,
        1713  +
            parent_automation_execution_id: self.parent_automation_execution_id,
        1714  +
            current_step_name: self.current_step_name,
        1715  +
            current_action: self.current_action,
        1716  +
            failure_message: self.failure_message,
        1717  +
            warning_message: self.warning_message,
        1718  +
            target_parameter_name: self.target_parameter_name,
        1719  +
            targets: self.targets,
        1720  +
            target_maps: self.target_maps,
        1721  +
            resolved_targets: self.resolved_targets,
        1722  +
            max_concurrency: self.max_concurrency,
        1723  +
            max_errors: self.max_errors,
        1724  +
            target: self.target,
        1725  +
            automation_type: self.automation_type,
        1726  +
            alarm_configuration: self.alarm_configuration,
        1727  +
            triggered_alarms: self.triggered_alarms,
        1728  +
            target_locations_url: self.target_locations_url,
        1729  +
            automation_subtype: self.automation_subtype,
        1730  +
            scheduled_time: self.scheduled_time,
        1731  +
            runbooks: self.runbooks,
        1732  +
            ops_item_id: self.ops_item_id,
        1733  +
            association_id: self.association_id,
        1734  +
            change_request_name: self.change_request_name,
        1735  +
        }
        1736  +
    }
        1737  +
}