AWS SDK

AWS SDK

rev. 2915cec5ef64cb1ed4992565a748d76a11505b3b

Files changed:

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

@@ -0,1 +0,122 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>The target resources in the third-party cloud environment.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub enum ConfigurationTargets {
           7  +
    /// <p>A list of Azure subscriptions to target.</p>
           8  +
    Subscriptions(::std::vec::Vec<crate::types::AzureSubscription>),
           9  +
    /// The `Unknown` variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version.
          10  +
    /// An unknown enum variant
          11  +
    ///
          12  +
    /// _Note: If you encounter this error, consider upgrading your SDK to the latest version._
          13  +
    /// The `Unknown` variant represents cases where the server sent a value that wasn't recognized
          14  +
    /// by the client. This can happen when the server adds new functionality, but the client has not been updated.
          15  +
    /// To investigate this, consider turning on debug logging to print the raw HTTP response.
          16  +
    #[non_exhaustive]
          17  +
    Unknown,
          18  +
}
          19  +
impl ConfigurationTargets {
          20  +
    #[allow(irrefutable_let_patterns)]
          21  +
    /// Tries to convert the enum instance into [`Subscriptions`](crate::types::ConfigurationTargets::Subscriptions), extracting the inner [`Vec`](::std::vec::Vec).
          22  +
    /// Returns `Err(&Self)` if it can't be converted.
          23  +
    pub fn as_subscriptions(&self) -> ::std::result::Result<&::std::vec::Vec<crate::types::AzureSubscription>, &Self> {
          24  +
        if let ConfigurationTargets::Subscriptions(val) = &self {
          25  +
            ::std::result::Result::Ok(val)
          26  +
        } else {
          27  +
            ::std::result::Result::Err(self)
          28  +
        }
          29  +
    }
          30  +
    /// Returns true if this is a [`Subscriptions`](crate::types::ConfigurationTargets::Subscriptions).
          31  +
    pub fn is_subscriptions(&self) -> bool {
          32  +
        self.as_subscriptions().is_ok()
          33  +
    }
          34  +
    /// Returns true if the enum instance is the `Unknown` variant.
          35  +
    pub fn is_unknown(&self) -> bool {
          36  +
        matches!(self, Self::Unknown)
          37  +
    }
          38  +
}
          39  +
static CONFIGURATIONTARGETS_MEMBER_SUBSCRIPTIONS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          40  +
    ::aws_smithy_schema::ShapeId::from_parts(
          41  +
        "com.amazonaws.ssm#AzureSubscriptionList$member",
          42  +
        "com.amazonaws.ssm",
          43  +
        "AzureSubscriptionList",
          44  +
    ),
          45  +
    ::aws_smithy_schema::ShapeType::Structure,
          46  +
    "member",
          47  +
    0,
          48  +
);
          49  +
static CONFIGURATIONTARGETS_MEMBER_SUBSCRIPTIONS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          50  +
    ::aws_smithy_schema::ShapeId::from_parts(
          51  +
        "com.amazonaws.ssm#ConfigurationTargets$Subscriptions",
          52  +
        "com.amazonaws.ssm",
          53  +
        "ConfigurationTargets",
          54  +
    ),
          55  +
    ::aws_smithy_schema::ShapeType::List,
          56  +
    "Subscriptions",
          57  +
    0,
          58  +
)
          59  +
.with_list_member(&CONFIGURATIONTARGETS_MEMBER_SUBSCRIPTIONS_MEMBER);
          60  +
static CONFIGURATIONTARGETS_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          61  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#ConfigurationTargets", "com.amazonaws.ssm", "ConfigurationTargets"),
          62  +
    ::aws_smithy_schema::ShapeType::Union,
          63  +
    &[&CONFIGURATIONTARGETS_MEMBER_SUBSCRIPTIONS],
          64  +
);
          65  +
impl ConfigurationTargets {
          66  +
    /// The schema for this shape.
          67  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &CONFIGURATIONTARGETS_SCHEMA;
          68  +
}
          69  +
impl ::aws_smithy_schema::serde::SerializableStruct for ConfigurationTargets {
          70  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          71  +
    fn serialize_members(
          72  +
        &self,
          73  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          74  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          75  +
        match self {
          76  +
            Self::Subscriptions(val) => {
          77  +
                ser.write_list(
          78  +
                    &CONFIGURATIONTARGETS_MEMBER_SUBSCRIPTIONS,
          79  +
                    &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          80  +
                        for item in val {
          81  +
                            ser.write_struct(crate::types::AzureSubscription::SCHEMA, item)?;
          82  +
                        }
          83  +
                        Ok(())
          84  +
                    },
          85  +
                )?;
          86  +
            }
          87  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
          88  +
        }
          89  +
        Ok(())
          90  +
    }
          91  +
}
          92  +
impl ConfigurationTargets {
          93  +
    /// Deserializes this union from a [`ShapeDeserializer`].
          94  +
    pub fn deserialize(
          95  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          96  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          97  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
          98  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
          99  +
        deserializer.read_struct(&CONFIGURATIONTARGETS_SCHEMA, &mut |member, deser| {
         100  +
            // A union holds exactly one member; the deserializer reports every key
         101  +
            // (known or not), so a second one is an error whatever it names.
         102  +
            if result.is_some() {
         103  +
                return Err(::aws_smithy_schema::serde::SerdeError::invalid_input(
         104  +
                    "encountered mixed variants in union",
         105  +
                ));
         106  +
            }
         107  +
            result = ::std::option::Option::Some(match member.member_index() {
         108  +
                Some(0) => Self::Subscriptions({
         109  +
                    let mut container = Vec::new();
         110  +
                    deser.read_list(member, &mut |deser| {
         111  +
                        container.push(crate::types::AzureSubscription::deserialize(deser)?);
         112  +
                        Ok(())
         113  +
                    })?;
         114  +
                    container
         115  +
                }),
         116  +
                _ => Self::Unknown,
         117  +
            });
         118  +
            Ok(())
         119  +
        })?;
         120  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         121  +
    }
         122  +
}

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

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

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

@@ -0,1 +0,1360 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Describes the association of a Amazon Web Services Systems Manager document (SSM document) and a managed node.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq)]
           6  +
pub struct CreateAssociationBatchRequestEntry {
           7  +
    /// <p>The name of the SSM document that contains the configuration information for the managed node. You can specify Command or Automation runbooks.</p>
           8  +
    /// <p>You can specify Amazon Web Services-predefined documents, documents you created, or a document that is shared with you from another account.</p>
           9  +
    /// <p>For SSM documents that are shared with you from other Amazon Web Services accounts, you must specify the complete SSM document ARN, in the following format:</p>
          10  +
    /// <p><code>arn:aws:ssm:<i>region</i>:<i>account-id</i>:document/<i>document-name</i> </code></p>
          11  +
    /// <p>For example:</p>
          12  +
    /// <p><code>arn:aws:ssm:us-east-2:12345678912:document/My-Shared-Document</code></p>
          13  +
    /// <p>For Amazon Web Services-predefined documents and SSM documents you created in your account, you only need to specify the document name. For example, <code>AWS-ApplyPatchBaseline</code> or <code>My-Document</code>.</p>
          14  +
    pub name: ::std::string::String,
          15  +
    /// <p>The managed node ID.</p><note>
          16  +
    /// <p><code>InstanceId</code> has been deprecated. To specify a managed node ID for an association, use the <code>Targets</code> parameter. Requests that include the parameter <code>InstanceID</code> with Systems Manager documents (SSM documents) that use schema version 2.0 or later will fail. In addition, if you use the parameter <code>InstanceId</code>, you can't use the parameters <code>AssociationName</code>, <code>DocumentVersion</code>, <code>MaxErrors</code>, <code>MaxConcurrency</code>, <code>OutputLocation</code>, or <code>ScheduleExpression</code>. To use these parameters, you must use the <code>Targets</code> parameter.</p>
          17  +
    /// </note>
          18  +
    pub instance_id: ::std::option::Option<::std::string::String>,
          19  +
    /// <p>A description of the parameters for a document.</p>
          20  +
    pub parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
          21  +
    /// <p>Specify the target for the association. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in Amazon Web Services Systems Manager.</p>
          22  +
    pub automation_target_parameter_name: ::std::option::Option<::std::string::String>,
          23  +
    /// <p>The document version.</p>
          24  +
    pub document_version: ::std::option::Option<::std::string::String>,
          25  +
    /// <p>The managed nodes targeted by the request.</p>
          26  +
    pub targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
          27  +
    /// <p>A cron expression that specifies a schedule when the association runs.</p>
          28  +
    pub schedule_expression: ::std::option::Option<::std::string::String>,
          29  +
    /// <p>An S3 bucket where you want to store the results of this request.</p>
          30  +
    pub output_location: ::std::option::Option<crate::types::InstanceAssociationOutputLocation>,
          31  +
    /// <p>Specify a descriptive name for the association.</p>
          32  +
    pub association_name: ::std::option::Option<::std::string::String>,
          33  +
    /// <p>The number of errors that are allowed before the system stops sending requests to run the association on additional targets. You can specify either an absolute number of errors, for example 10, or a percentage of the target set, for example 10%. If you specify 3, for example, the system stops sending requests when the fourth error is received. If you specify 0, then the system stops sending requests after the first error is returned. If you run an association on 50 managed nodes and set <code>MaxError</code> to 10%, then the system stops sending the request when the sixth error is received.</p>
          34  +
    /// <p>Executions that are already running an association when <code>MaxErrors</code> is reached are allowed to complete, but some of these executions may fail as well. If you need to ensure that there won't be more than max-errors failed executions, set <code>MaxConcurrency</code> to 1 so that executions proceed one at a time.</p>
          35  +
    pub max_errors: ::std::option::Option<::std::string::String>,
          36  +
    /// <p>The maximum number of targets allowed to run the association at the same time. You can specify a number, for example 10, or a percentage of the target set, for example 10%. The default value is 100%, which means all targets run the association at the same time.</p>
          37  +
    /// <p>If a new managed node starts and attempts to run an association while Systems Manager is running <code>MaxConcurrency</code> associations, the association is allowed to run. During the next association interval, the new managed node will process its association within the limit specified for <code>MaxConcurrency</code>.</p>
          38  +
    pub max_concurrency: ::std::option::Option<::std::string::String>,
          39  +
    /// <p>The severity level to assign to the association.</p>
          40  +
    pub compliance_severity: ::std::option::Option<crate::types::AssociationComplianceSeverity>,
          41  +
    /// <p>The mode for generating association compliance. You can specify <code>AUTO</code> or <code>MANUAL</code>. In <code>AUTO</code> mode, the system uses the status of the association execution to determine the compliance status. If the association execution runs successfully, then the association is <code>COMPLIANT</code>. If the association execution doesn't run successfully, the association is <code>NON-COMPLIANT</code>.</p>
          42  +
    /// <p>In <code>MANUAL</code> mode, you must specify the <code>AssociationId</code> as a parameter for the <code>PutComplianceItems</code> API operation. In this case, compliance data isn't managed by State Manager, a tool in Amazon Web Services Systems Manager. It is managed by your direct call to the <code>PutComplianceItems</code> API operation.</p>
          43  +
    /// <p>By default, all associations use <code>AUTO</code> mode.</p>
          44  +
    pub sync_compliance: ::std::option::Option<crate::types::AssociationSyncCompliance>,
          45  +
    /// <p>By default, when you create a new association, the system runs it immediately after it is created and then according to the schedule you specified and when target changes are detected. Specify <code>true</code> for <code>ApplyOnlyAtCronInterval</code> if you want the association to run only according to the schedule you specified.</p>
          46  +
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#state-manager-about-scheduling">Understanding when associations are applied to resources</a> and <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#runbook-target-updates">&gt;About target updates with Automation runbooks</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
          47  +
    /// <p>This parameter isn't supported for rate expressions.</p>
          48  +
    pub apply_only_at_cron_interval: bool,
          49  +
    /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar">Amazon Web Services Systems Manager Change Calendar</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
          50  +
    pub calendar_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          51  +
    /// <p>Use this action to create an association in multiple Regions and multiple accounts.</p>
          52  +
    pub target_locations: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>,
          53  +
    /// <p>Number of days to wait after the scheduled day to run an association.</p>
          54  +
    pub schedule_offset: ::std::option::Option<i32>,
          55  +
    /// <p>The number of hours the association can run before it is canceled. Duration applies to associations that are currently running, and any pending and in progress commands on all targets. If a target was taken offline for the association to run, it is made available again immediately, without a reboot.</p>
          56  +
    /// <p>The <code>Duration</code> parameter applies only when both these conditions are true:</p>
          57  +
    /// <ul>
          58  +
    /// <li>
          59  +
    /// <p>The association for which you specify a duration is cancelable according to the parameters of the SSM command document or Automation runbook associated with this execution.</p></li>
          60  +
    /// <li>
          61  +
    /// <p>The command specifies the <code> <a href="https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateAssociationBatchRequestEntry.html#systemsmanager-Type-CreateAssociationBatchRequestEntry-ApplyOnlyAtCronInterval">ApplyOnlyAtCronInterval</a> </code> parameter, which means that the association doesn't run immediately after it is created, but only according to the specified schedule.</p></li>
          62  +
    /// </ul>
          63  +
    pub duration: ::std::option::Option<i32>,
          64  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
          65  +
    pub target_maps:
          66  +
        ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
          67  +
    /// <p>The details for the CloudWatch alarm you want to apply to an automation or command.</p>
          68  +
    pub alarm_configuration: ::std::option::Option<crate::types::AlarmConfiguration>,
          69  +
}
          70  +
impl CreateAssociationBatchRequestEntry {
          71  +
    /// <p>The name of the SSM document that contains the configuration information for the managed node. You can specify Command or Automation runbooks.</p>
          72  +
    /// <p>You can specify Amazon Web Services-predefined documents, documents you created, or a document that is shared with you from another account.</p>
          73  +
    /// <p>For SSM documents that are shared with you from other Amazon Web Services accounts, you must specify the complete SSM document ARN, in the following format:</p>
          74  +
    /// <p><code>arn:aws:ssm:<i>region</i>:<i>account-id</i>:document/<i>document-name</i> </code></p>
          75  +
    /// <p>For example:</p>
          76  +
    /// <p><code>arn:aws:ssm:us-east-2:12345678912:document/My-Shared-Document</code></p>
          77  +
    /// <p>For Amazon Web Services-predefined documents and SSM documents you created in your account, you only need to specify the document name. For example, <code>AWS-ApplyPatchBaseline</code> or <code>My-Document</code>.</p>
          78  +
    pub fn name(&self) -> &str {
          79  +
        use std::ops::Deref;
          80  +
        self.name.deref()
          81  +
    }
          82  +
    /// <p>The managed node ID.</p><note>
          83  +
    /// <p><code>InstanceId</code> has been deprecated. To specify a managed node ID for an association, use the <code>Targets</code> parameter. Requests that include the parameter <code>InstanceID</code> with Systems Manager documents (SSM documents) that use schema version 2.0 or later will fail. In addition, if you use the parameter <code>InstanceId</code>, you can't use the parameters <code>AssociationName</code>, <code>DocumentVersion</code>, <code>MaxErrors</code>, <code>MaxConcurrency</code>, <code>OutputLocation</code>, or <code>ScheduleExpression</code>. To use these parameters, you must use the <code>Targets</code> parameter.</p>
          84  +
    /// </note>
          85  +
    pub fn instance_id(&self) -> ::std::option::Option<&str> {
          86  +
        self.instance_id.as_deref()
          87  +
    }
          88  +
    /// <p>A description of the parameters for a document.</p>
          89  +
    pub fn parameters(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
          90  +
        self.parameters.as_ref()
          91  +
    }
          92  +
    /// <p>Specify the target for the association. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in Amazon Web Services Systems Manager.</p>
          93  +
    pub fn automation_target_parameter_name(&self) -> ::std::option::Option<&str> {
          94  +
        self.automation_target_parameter_name.as_deref()
          95  +
    }
          96  +
    /// <p>The document version.</p>
          97  +
    pub fn document_version(&self) -> ::std::option::Option<&str> {
          98  +
        self.document_version.as_deref()
          99  +
    }
         100  +
    /// <p>The managed nodes targeted by the request.</p>
         101  +
    ///
         102  +
    /// 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()`.
         103  +
    pub fn targets(&self) -> &[crate::types::Target] {
         104  +
        self.targets.as_deref().unwrap_or_default()
         105  +
    }
         106  +
    /// <p>A cron expression that specifies a schedule when the association runs.</p>
         107  +
    pub fn schedule_expression(&self) -> ::std::option::Option<&str> {
         108  +
        self.schedule_expression.as_deref()
         109  +
    }
         110  +
    /// <p>An S3 bucket where you want to store the results of this request.</p>
         111  +
    pub fn output_location(&self) -> ::std::option::Option<&crate::types::InstanceAssociationOutputLocation> {
         112  +
        self.output_location.as_ref()
         113  +
    }
         114  +
    /// <p>Specify a descriptive name for the association.</p>
         115  +
    pub fn association_name(&self) -> ::std::option::Option<&str> {
         116  +
        self.association_name.as_deref()
         117  +
    }
         118  +
    /// <p>The number of errors that are allowed before the system stops sending requests to run the association on additional targets. You can specify either an absolute number of errors, for example 10, or a percentage of the target set, for example 10%. If you specify 3, for example, the system stops sending requests when the fourth error is received. If you specify 0, then the system stops sending requests after the first error is returned. If you run an association on 50 managed nodes and set <code>MaxError</code> to 10%, then the system stops sending the request when the sixth error is received.</p>
         119  +
    /// <p>Executions that are already running an association when <code>MaxErrors</code> is reached are allowed to complete, but some of these executions may fail as well. If you need to ensure that there won't be more than max-errors failed executions, set <code>MaxConcurrency</code> to 1 so that executions proceed one at a time.</p>
         120  +
    pub fn max_errors(&self) -> ::std::option::Option<&str> {
         121  +
        self.max_errors.as_deref()
         122  +
    }
         123  +
    /// <p>The maximum number of targets allowed to run the association at the same time. You can specify a number, for example 10, or a percentage of the target set, for example 10%. The default value is 100%, which means all targets run the association at the same time.</p>
         124  +
    /// <p>If a new managed node starts and attempts to run an association while Systems Manager is running <code>MaxConcurrency</code> associations, the association is allowed to run. During the next association interval, the new managed node will process its association within the limit specified for <code>MaxConcurrency</code>.</p>
         125  +
    pub fn max_concurrency(&self) -> ::std::option::Option<&str> {
         126  +
        self.max_concurrency.as_deref()
         127  +
    }
         128  +
    /// <p>The severity level to assign to the association.</p>
         129  +
    pub fn compliance_severity(&self) -> ::std::option::Option<&crate::types::AssociationComplianceSeverity> {
         130  +
        self.compliance_severity.as_ref()
         131  +
    }
         132  +
    /// <p>The mode for generating association compliance. You can specify <code>AUTO</code> or <code>MANUAL</code>. In <code>AUTO</code> mode, the system uses the status of the association execution to determine the compliance status. If the association execution runs successfully, then the association is <code>COMPLIANT</code>. If the association execution doesn't run successfully, the association is <code>NON-COMPLIANT</code>.</p>
         133  +
    /// <p>In <code>MANUAL</code> mode, you must specify the <code>AssociationId</code> as a parameter for the <code>PutComplianceItems</code> API operation. In this case, compliance data isn't managed by State Manager, a tool in Amazon Web Services Systems Manager. It is managed by your direct call to the <code>PutComplianceItems</code> API operation.</p>
         134  +
    /// <p>By default, all associations use <code>AUTO</code> mode.</p>
         135  +
    pub fn sync_compliance(&self) -> ::std::option::Option<&crate::types::AssociationSyncCompliance> {
         136  +
        self.sync_compliance.as_ref()
         137  +
    }
         138  +
    /// <p>By default, when you create a new association, the system runs it immediately after it is created and then according to the schedule you specified and when target changes are detected. Specify <code>true</code> for <code>ApplyOnlyAtCronInterval</code> if you want the association to run only according to the schedule you specified.</p>
         139  +
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#state-manager-about-scheduling">Understanding when associations are applied to resources</a> and <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#runbook-target-updates">&gt;About target updates with Automation runbooks</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         140  +
    /// <p>This parameter isn't supported for rate expressions.</p>
         141  +
    pub fn apply_only_at_cron_interval(&self) -> bool {
         142  +
        self.apply_only_at_cron_interval
         143  +
    }
         144  +
    /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar">Amazon Web Services Systems Manager Change Calendar</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         145  +
    ///
         146  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.calendar_names.is_none()`.
         147  +
    pub fn calendar_names(&self) -> &[::std::string::String] {
         148  +
        self.calendar_names.as_deref().unwrap_or_default()
         149  +
    }
         150  +
    /// <p>Use this action to create an association in multiple Regions and multiple accounts.</p>
         151  +
    ///
         152  +
    /// 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()`.
         153  +
    pub fn target_locations(&self) -> &[crate::types::TargetLocation] {
         154  +
        self.target_locations.as_deref().unwrap_or_default()
         155  +
    }
         156  +
    /// <p>Number of days to wait after the scheduled day to run an association.</p>
         157  +
    pub fn schedule_offset(&self) -> ::std::option::Option<i32> {
         158  +
        self.schedule_offset
         159  +
    }
         160  +
    /// <p>The number of hours the association can run before it is canceled. Duration applies to associations that are currently running, and any pending and in progress commands on all targets. If a target was taken offline for the association to run, it is made available again immediately, without a reboot.</p>
         161  +
    /// <p>The <code>Duration</code> parameter applies only when both these conditions are true:</p>
         162  +
    /// <ul>
         163  +
    /// <li>
         164  +
    /// <p>The association for which you specify a duration is cancelable according to the parameters of the SSM command document or Automation runbook associated with this execution.</p></li>
         165  +
    /// <li>
         166  +
    /// <p>The command specifies the <code> <a href="https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateAssociationBatchRequestEntry.html#systemsmanager-Type-CreateAssociationBatchRequestEntry-ApplyOnlyAtCronInterval">ApplyOnlyAtCronInterval</a> </code> parameter, which means that the association doesn't run immediately after it is created, but only according to the specified schedule.</p></li>
         167  +
    /// </ul>
         168  +
    pub fn duration(&self) -> ::std::option::Option<i32> {
         169  +
        self.duration
         170  +
    }
         171  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
         172  +
    ///
         173  +
    /// 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()`.
         174  +
    pub fn target_maps(&self) -> &[::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>] {
         175  +
        self.target_maps.as_deref().unwrap_or_default()
         176  +
    }
         177  +
    /// <p>The details for the CloudWatch alarm you want to apply to an automation or command.</p>
         178  +
    pub fn alarm_configuration(&self) -> ::std::option::Option<&crate::types::AlarmConfiguration> {
         179  +
        self.alarm_configuration.as_ref()
         180  +
    }
         181  +
}
         182  +
impl ::std::fmt::Debug for CreateAssociationBatchRequestEntry {
         183  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         184  +
        let mut formatter = f.debug_struct("CreateAssociationBatchRequestEntry");
         185  +
        formatter.field("name", &self.name);
         186  +
        formatter.field("instance_id", &self.instance_id);
         187  +
        formatter.field("parameters", &"*** Sensitive Data Redacted ***");
         188  +
        formatter.field("automation_target_parameter_name", &self.automation_target_parameter_name);
         189  +
        formatter.field("document_version", &self.document_version);
         190  +
        formatter.field("targets", &self.targets);
         191  +
        formatter.field("schedule_expression", &self.schedule_expression);
         192  +
        formatter.field("output_location", &self.output_location);
         193  +
        formatter.field("association_name", &self.association_name);
         194  +
        formatter.field("max_errors", &self.max_errors);
         195  +
        formatter.field("max_concurrency", &self.max_concurrency);
         196  +
        formatter.field("compliance_severity", &self.compliance_severity);
         197  +
        formatter.field("sync_compliance", &self.sync_compliance);
         198  +
        formatter.field("apply_only_at_cron_interval", &self.apply_only_at_cron_interval);
         199  +
        formatter.field("calendar_names", &self.calendar_names);
         200  +
        formatter.field("target_locations", &self.target_locations);
         201  +
        formatter.field("schedule_offset", &self.schedule_offset);
         202  +
        formatter.field("duration", &self.duration);
         203  +
        formatter.field("target_maps", &self.target_maps);
         204  +
        formatter.field("alarm_configuration", &self.alarm_configuration);
         205  +
        formatter.finish()
         206  +
    }
         207  +
}
         208  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         209  +
    ::aws_smithy_schema::ShapeId::from_parts(
         210  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$Name",
         211  +
        "com.amazonaws.ssm",
         212  +
        "CreateAssociationBatchRequestEntry",
         213  +
    ),
         214  +
    ::aws_smithy_schema::ShapeType::String,
         215  +
    "Name",
         216  +
    0,
         217  +
);
         218  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         219  +
    ::aws_smithy_schema::ShapeId::from_parts(
         220  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$InstanceId",
         221  +
        "com.amazonaws.ssm",
         222  +
        "CreateAssociationBatchRequestEntry",
         223  +
    ),
         224  +
    ::aws_smithy_schema::ShapeType::String,
         225  +
    "InstanceId",
         226  +
    1,
         227  +
);
         228  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> =
         229  +
    ::aws_smithy_schema::Schema::new_member(
         230  +
        ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#ParameterValueList$member", "com.amazonaws.ssm", "ParameterValueList"),
         231  +
        ::aws_smithy_schema::ShapeType::String,
         232  +
        "member",
         233  +
        0,
         234  +
    );
         235  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         236  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Parameters$key", "com.amazonaws.ssm", "Parameters"),
         237  +
    ::aws_smithy_schema::ShapeType::String,
         238  +
    "key",
         239  +
    0,
         240  +
);
         241  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         242  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Parameters$value", "com.amazonaws.ssm", "Parameters"),
         243  +
    ::aws_smithy_schema::ShapeType::List,
         244  +
    "value",
         245  +
    1,
         246  +
)
         247  +
.with_list_member(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_VALUE_MEMBER);
         248  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         249  +
    ::aws_smithy_schema::ShapeId::from_parts(
         250  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$Parameters",
         251  +
        "com.amazonaws.ssm",
         252  +
        "CreateAssociationBatchRequestEntry",
         253  +
    ),
         254  +
    ::aws_smithy_schema::ShapeType::Map,
         255  +
    "Parameters",
         256  +
    2,
         257  +
)
         258  +
.with_map_members(
         259  +
    &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_KEY,
         260  +
    &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_VALUE,
         261  +
);
         262  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_AUTOMATION_TARGET_PARAMETER_NAME: ::aws_smithy_schema::Schema<'static> =
         263  +
    ::aws_smithy_schema::Schema::new_member(
         264  +
        ::aws_smithy_schema::ShapeId::from_parts(
         265  +
            "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$AutomationTargetParameterName",
         266  +
            "com.amazonaws.ssm",
         267  +
            "CreateAssociationBatchRequestEntry",
         268  +
        ),
         269  +
        ::aws_smithy_schema::ShapeType::String,
         270  +
        "AutomationTargetParameterName",
         271  +
        3,
         272  +
    );
         273  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_DOCUMENT_VERSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         274  +
    ::aws_smithy_schema::ShapeId::from_parts(
         275  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$DocumentVersion",
         276  +
        "com.amazonaws.ssm",
         277  +
        "CreateAssociationBatchRequestEntry",
         278  +
    ),
         279  +
    ::aws_smithy_schema::ShapeType::String,
         280  +
    "DocumentVersion",
         281  +
    4,
         282  +
);
         283  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGETS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         284  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Targets$member", "com.amazonaws.ssm", "Targets"),
         285  +
    ::aws_smithy_schema::ShapeType::Structure,
         286  +
    "member",
         287  +
    0,
         288  +
);
         289  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGETS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         290  +
    ::aws_smithy_schema::ShapeId::from_parts(
         291  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$Targets",
         292  +
        "com.amazonaws.ssm",
         293  +
        "CreateAssociationBatchRequestEntry",
         294  +
    ),
         295  +
    ::aws_smithy_schema::ShapeType::List,
         296  +
    "Targets",
         297  +
    5,
         298  +
)
         299  +
.with_list_member(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGETS_MEMBER);
         300  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SCHEDULE_EXPRESSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         301  +
    ::aws_smithy_schema::ShapeId::from_parts(
         302  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$ScheduleExpression",
         303  +
        "com.amazonaws.ssm",
         304  +
        "CreateAssociationBatchRequestEntry",
         305  +
    ),
         306  +
    ::aws_smithy_schema::ShapeType::String,
         307  +
    "ScheduleExpression",
         308  +
    6,
         309  +
);
         310  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_OUTPUT_LOCATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         311  +
    ::aws_smithy_schema::ShapeId::from_parts(
         312  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$OutputLocation",
         313  +
        "com.amazonaws.ssm",
         314  +
        "CreateAssociationBatchRequestEntry",
         315  +
    ),
         316  +
    ::aws_smithy_schema::ShapeType::Structure,
         317  +
    "OutputLocation",
         318  +
    7,
         319  +
);
         320  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_ASSOCIATION_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         321  +
    ::aws_smithy_schema::ShapeId::from_parts(
         322  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$AssociationName",
         323  +
        "com.amazonaws.ssm",
         324  +
        "CreateAssociationBatchRequestEntry",
         325  +
    ),
         326  +
    ::aws_smithy_schema::ShapeType::String,
         327  +
    "AssociationName",
         328  +
    8,
         329  +
);
         330  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_MAX_ERRORS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         331  +
    ::aws_smithy_schema::ShapeId::from_parts(
         332  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$MaxErrors",
         333  +
        "com.amazonaws.ssm",
         334  +
        "CreateAssociationBatchRequestEntry",
         335  +
    ),
         336  +
    ::aws_smithy_schema::ShapeType::String,
         337  +
    "MaxErrors",
         338  +
    9,
         339  +
);
         340  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_MAX_CONCURRENCY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         341  +
    ::aws_smithy_schema::ShapeId::from_parts(
         342  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$MaxConcurrency",
         343  +
        "com.amazonaws.ssm",
         344  +
        "CreateAssociationBatchRequestEntry",
         345  +
    ),
         346  +
    ::aws_smithy_schema::ShapeType::String,
         347  +
    "MaxConcurrency",
         348  +
    10,
         349  +
);
         350  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_COMPLIANCE_SEVERITY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         351  +
    ::aws_smithy_schema::ShapeId::from_parts(
         352  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$ComplianceSeverity",
         353  +
        "com.amazonaws.ssm",
         354  +
        "CreateAssociationBatchRequestEntry",
         355  +
    ),
         356  +
    ::aws_smithy_schema::ShapeType::String,
         357  +
    "ComplianceSeverity",
         358  +
    11,
         359  +
);
         360  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SYNC_COMPLIANCE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         361  +
    ::aws_smithy_schema::ShapeId::from_parts(
         362  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$SyncCompliance",
         363  +
        "com.amazonaws.ssm",
         364  +
        "CreateAssociationBatchRequestEntry",
         365  +
    ),
         366  +
    ::aws_smithy_schema::ShapeType::String,
         367  +
    "SyncCompliance",
         368  +
    12,
         369  +
);
         370  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_APPLY_ONLY_AT_CRON_INTERVAL: ::aws_smithy_schema::Schema<'static> =
         371  +
    ::aws_smithy_schema::Schema::new_member(
         372  +
        ::aws_smithy_schema::ShapeId::from_parts(
         373  +
            "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$ApplyOnlyAtCronInterval",
         374  +
            "com.amazonaws.ssm",
         375  +
            "CreateAssociationBatchRequestEntry",
         376  +
        ),
         377  +
        ::aws_smithy_schema::ShapeType::Boolean,
         378  +
        "ApplyOnlyAtCronInterval",
         379  +
        13,
         380  +
    );
         381  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_CALENDAR_NAMES_MEMBER: ::aws_smithy_schema::Schema<'static> =
         382  +
    ::aws_smithy_schema::Schema::new_member(
         383  +
        ::aws_smithy_schema::ShapeId::from_parts(
         384  +
            "com.amazonaws.ssm#CalendarNameOrARNList$member",
         385  +
            "com.amazonaws.ssm",
         386  +
            "CalendarNameOrARNList",
         387  +
        ),
         388  +
        ::aws_smithy_schema::ShapeType::String,
         389  +
        "member",
         390  +
        0,
         391  +
    );
         392  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_CALENDAR_NAMES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         393  +
    ::aws_smithy_schema::ShapeId::from_parts(
         394  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$CalendarNames",
         395  +
        "com.amazonaws.ssm",
         396  +
        "CreateAssociationBatchRequestEntry",
         397  +
    ),
         398  +
    ::aws_smithy_schema::ShapeType::List,
         399  +
    "CalendarNames",
         400  +
    14,
         401  +
)
         402  +
.with_list_member(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_CALENDAR_NAMES_MEMBER);
         403  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_LOCATIONS_MEMBER: ::aws_smithy_schema::Schema<'static> =
         404  +
    ::aws_smithy_schema::Schema::new_member(
         405  +
        ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetLocations$member", "com.amazonaws.ssm", "TargetLocations"),
         406  +
        ::aws_smithy_schema::ShapeType::Structure,
         407  +
        "member",
         408  +
        0,
         409  +
    );
         410  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_LOCATIONS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         411  +
    ::aws_smithy_schema::ShapeId::from_parts(
         412  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$TargetLocations",
         413  +
        "com.amazonaws.ssm",
         414  +
        "CreateAssociationBatchRequestEntry",
         415  +
    ),
         416  +
    ::aws_smithy_schema::ShapeType::List,
         417  +
    "TargetLocations",
         418  +
    15,
         419  +
)
         420  +
.with_list_member(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_LOCATIONS_MEMBER);
         421  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SCHEDULE_OFFSET: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         422  +
    ::aws_smithy_schema::ShapeId::from_parts(
         423  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$ScheduleOffset",
         424  +
        "com.amazonaws.ssm",
         425  +
        "CreateAssociationBatchRequestEntry",
         426  +
    ),
         427  +
    ::aws_smithy_schema::ShapeType::Integer,
         428  +
    "ScheduleOffset",
         429  +
    16,
         430  +
);
         431  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_DURATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         432  +
    ::aws_smithy_schema::ShapeId::from_parts(
         433  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$Duration",
         434  +
        "com.amazonaws.ssm",
         435  +
        "CreateAssociationBatchRequestEntry",
         436  +
    ),
         437  +
    ::aws_smithy_schema::ShapeType::Integer,
         438  +
    "Duration",
         439  +
    17,
         440  +
);
         441  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> =
         442  +
    ::aws_smithy_schema::Schema::new_member(
         443  +
        ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMapValueList$member", "com.amazonaws.ssm", "TargetMapValueList"),
         444  +
        ::aws_smithy_schema::ShapeType::String,
         445  +
        "member",
         446  +
        0,
         447  +
    );
         448  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> =
         449  +
    ::aws_smithy_schema::Schema::new_member(
         450  +
        ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$key", "com.amazonaws.ssm", "TargetMap"),
         451  +
        ::aws_smithy_schema::ShapeType::String,
         452  +
        "key",
         453  +
        0,
         454  +
    );
         455  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> =
         456  +
    ::aws_smithy_schema::Schema::new_member(
         457  +
        ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$value", "com.amazonaws.ssm", "TargetMap"),
         458  +
        ::aws_smithy_schema::ShapeType::List,
         459  +
        "value",
         460  +
        1,
         461  +
    )
         462  +
    .with_list_member(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER);
         463  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         464  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMaps$member", "com.amazonaws.ssm", "TargetMaps"),
         465  +
    ::aws_smithy_schema::ShapeType::Map,
         466  +
    "member",
         467  +
    0,
         468  +
)
         469  +
.with_map_members(
         470  +
    &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_KEY,
         471  +
    &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_VALUE,
         472  +
);
         473  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         474  +
    ::aws_smithy_schema::ShapeId::from_parts(
         475  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$TargetMaps",
         476  +
        "com.amazonaws.ssm",
         477  +
        "CreateAssociationBatchRequestEntry",
         478  +
    ),
         479  +
    ::aws_smithy_schema::ShapeType::List,
         480  +
    "TargetMaps",
         481  +
    18,
         482  +
)
         483  +
.with_list_member(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER);
         484  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_ALARM_CONFIGURATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         485  +
    ::aws_smithy_schema::ShapeId::from_parts(
         486  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry$AlarmConfiguration",
         487  +
        "com.amazonaws.ssm",
         488  +
        "CreateAssociationBatchRequestEntry",
         489  +
    ),
         490  +
    ::aws_smithy_schema::ShapeType::Structure,
         491  +
    "AlarmConfiguration",
         492  +
    19,
         493  +
);
         494  +
static CREATEASSOCIATIONBATCHREQUESTENTRY_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         495  +
    ::aws_smithy_schema::ShapeId::from_parts(
         496  +
        "com.amazonaws.ssm#CreateAssociationBatchRequestEntry",
         497  +
        "com.amazonaws.ssm",
         498  +
        "CreateAssociationBatchRequestEntry",
         499  +
    ),
         500  +
    ::aws_smithy_schema::ShapeType::Structure,
         501  +
    &[
         502  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_NAME,
         503  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_INSTANCE_ID,
         504  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS,
         505  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_AUTOMATION_TARGET_PARAMETER_NAME,
         506  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_DOCUMENT_VERSION,
         507  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGETS,
         508  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SCHEDULE_EXPRESSION,
         509  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_OUTPUT_LOCATION,
         510  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_ASSOCIATION_NAME,
         511  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_MAX_ERRORS,
         512  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_MAX_CONCURRENCY,
         513  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_COMPLIANCE_SEVERITY,
         514  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SYNC_COMPLIANCE,
         515  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_APPLY_ONLY_AT_CRON_INTERVAL,
         516  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_CALENDAR_NAMES,
         517  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_LOCATIONS,
         518  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SCHEDULE_OFFSET,
         519  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_DURATION,
         520  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS,
         521  +
        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_ALARM_CONFIGURATION,
         522  +
    ],
         523  +
);
         524  +
impl CreateAssociationBatchRequestEntry {
         525  +
    /// The schema for this shape.
         526  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &CREATEASSOCIATIONBATCHREQUESTENTRY_SCHEMA;
         527  +
}
         528  +
impl ::aws_smithy_schema::serde::SerializableStruct for CreateAssociationBatchRequestEntry {
         529  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         530  +
    fn serialize_members(
         531  +
        &self,
         532  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         533  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         534  +
        {
         535  +
            let val = &self.name;
         536  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_NAME, val)?;
         537  +
        }
         538  +
        if let Some(ref val) = self.instance_id {
         539  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_INSTANCE_ID, val)?;
         540  +
        }
         541  +
        if let Some(ref val) = self.parameters {
         542  +
            ser.write_map(
         543  +
                &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS,
         544  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         545  +
                    for (key, value) in val {
         546  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         547  +
         548  +
                        ser.write_list(
         549  +
                            &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_VALUE,
         550  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         551  +
                                for item in value {
         552  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         553  +
                                }
         554  +
                                Ok(())
         555  +
                            },
         556  +
                        )?;
         557  +
                    }
         558  +
                    Ok(())
         559  +
                },
         560  +
            )?;
         561  +
        }
         562  +
        if let Some(ref val) = self.automation_target_parameter_name {
         563  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_AUTOMATION_TARGET_PARAMETER_NAME, val)?;
         564  +
        }
         565  +
        if let Some(ref val) = self.document_version {
         566  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_DOCUMENT_VERSION, val)?;
         567  +
        }
         568  +
        if let Some(ref val) = self.targets {
         569  +
            ser.write_list(
         570  +
                &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGETS,
         571  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         572  +
                    for item in val {
         573  +
                        ser.write_struct(crate::types::Target::SCHEMA, item)?;
         574  +
                    }
         575  +
                    Ok(())
         576  +
                },
         577  +
            )?;
         578  +
        }
         579  +
        if let Some(ref val) = self.schedule_expression {
         580  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SCHEDULE_EXPRESSION, val)?;
         581  +
        }
         582  +
        if let Some(ref val) = self.output_location {
         583  +
            ser.write_struct(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_OUTPUT_LOCATION, val)?;
         584  +
        }
         585  +
        if let Some(ref val) = self.association_name {
         586  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_ASSOCIATION_NAME, val)?;
         587  +
        }
         588  +
        if let Some(ref val) = self.max_errors {
         589  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_MAX_ERRORS, val)?;
         590  +
        }
         591  +
        if let Some(ref val) = self.max_concurrency {
         592  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_MAX_CONCURRENCY, val)?;
         593  +
        }
         594  +
        if let Some(ref val) = self.compliance_severity {
         595  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_COMPLIANCE_SEVERITY, val.as_str())?;
         596  +
        }
         597  +
        if let Some(ref val) = self.sync_compliance {
         598  +
            ser.write_string(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SYNC_COMPLIANCE, val.as_str())?;
         599  +
        }
         600  +
        {
         601  +
            let val = &self.apply_only_at_cron_interval;
         602  +
            ser.write_boolean(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_APPLY_ONLY_AT_CRON_INTERVAL, *val)?;
         603  +
        }
         604  +
        if let Some(ref val) = self.calendar_names {
         605  +
            ser.write_list(
         606  +
                &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_CALENDAR_NAMES,
         607  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         608  +
                    for item in val {
         609  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         610  +
                    }
         611  +
                    Ok(())
         612  +
                },
         613  +
            )?;
         614  +
        }
         615  +
        if let Some(ref val) = self.target_locations {
         616  +
            ser.write_list(
         617  +
                &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_LOCATIONS,
         618  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         619  +
                    for item in val {
         620  +
                        ser.write_struct(crate::types::TargetLocation::SCHEMA, item)?;
         621  +
                    }
         622  +
                    Ok(())
         623  +
                },
         624  +
            )?;
         625  +
        }
         626  +
        if let Some(ref val) = self.schedule_offset {
         627  +
            ser.write_integer(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_SCHEDULE_OFFSET, *val)?;
         628  +
        }
         629  +
        if let Some(ref val) = self.duration {
         630  +
            ser.write_integer(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_DURATION, *val)?;
         631  +
        }
         632  +
        if let Some(ref val) = self.target_maps {
         633  +
            ser.write_list(
         634  +
                &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS,
         635  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         636  +
                    for item in val {
         637  +
                        ser.write_map(
         638  +
                            &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER,
         639  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         640  +
                                for (key, value) in item {
         641  +
                                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         642  +
         643  +
                                    ser.write_list(
         644  +
                                        &CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_VALUE,
         645  +
                                        &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         646  +
                                            for item in value {
         647  +
                                                ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         648  +
                                            }
         649  +
                                            Ok(())
         650  +
                                        },
         651  +
                                    )?;
         652  +
                                }
         653  +
                                Ok(())
         654  +
                            },
         655  +
                        )?;
         656  +
                    }
         657  +
                    Ok(())
         658  +
                },
         659  +
            )?;
         660  +
        }
         661  +
        if let Some(ref val) = self.alarm_configuration {
         662  +
            ser.write_struct(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_ALARM_CONFIGURATION, val)?;
         663  +
        }
         664  +
        Ok(())
         665  +
    }
         666  +
}
         667  +
impl CreateAssociationBatchRequestEntry {
         668  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         669  +
    pub fn deserialize(
         670  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         671  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         672  +
        #[allow(unused_variables, unused_mut)]
         673  +
        let mut builder = Self::builder();
         674  +
        #[allow(
         675  +
            unused_variables,
         676  +
            unreachable_code,
         677  +
            clippy::single_match,
         678  +
            clippy::match_single_binding,
         679  +
            clippy::diverging_sub_expression
         680  +
        )]
         681  +
        deserializer.read_struct(&CREATEASSOCIATIONBATCHREQUESTENTRY_SCHEMA, &mut |member, deser| {
         682  +
            match member.member_index() {
         683  +
                Some(0) => {
         684  +
                    builder.name = Some(deser.read_string(member)?);
         685  +
                }
         686  +
                Some(1) => {
         687  +
                    if deser.is_null() {
         688  +
                        deser.read_null()?;
         689  +
                    } else {
         690  +
                        builder.instance_id = Some(deser.read_string(member)?);
         691  +
                    }
         692  +
                }
         693  +
                Some(2) => {
         694  +
                    if deser.is_null() {
         695  +
                        deser.read_null()?;
         696  +
                    } else {
         697  +
                        builder.parameters = Some({
         698  +
                            let mut container = std::collections::HashMap::new();
         699  +
                            deser.read_map(member, &mut |key, deser| {
         700  +
                                container.insert(key, {
         701  +
                                    let mut list = Vec::new();
         702  +
                                    deser.read_list(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_PARAMETERS_VALUE, &mut |deser| {
         703  +
                                        list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
         704  +
                                        Ok(())
         705  +
                                    })?;
         706  +
                                    list
         707  +
                                });
         708  +
                                Ok(())
         709  +
                            })?;
         710  +
                            container
         711  +
                        });
         712  +
                    }
         713  +
                }
         714  +
                Some(3) => {
         715  +
                    if deser.is_null() {
         716  +
                        deser.read_null()?;
         717  +
                    } else {
         718  +
                        builder.automation_target_parameter_name = Some(deser.read_string(member)?);
         719  +
                    }
         720  +
                }
         721  +
                Some(4) => {
         722  +
                    if deser.is_null() {
         723  +
                        deser.read_null()?;
         724  +
                    } else {
         725  +
                        builder.document_version = Some(deser.read_string(member)?);
         726  +
                    }
         727  +
                }
         728  +
                Some(5) => {
         729  +
                    if deser.is_null() {
         730  +
                        deser.read_null()?;
         731  +
                    } else {
         732  +
                        builder.targets = Some({
         733  +
                            let mut container = Vec::new();
         734  +
                            deser.read_list(member, &mut |deser| {
         735  +
                                container.push(crate::types::Target::deserialize(deser)?);
         736  +
                                Ok(())
         737  +
                            })?;
         738  +
                            container
         739  +
                        });
         740  +
                    }
         741  +
                }
         742  +
                Some(6) => {
         743  +
                    if deser.is_null() {
         744  +
                        deser.read_null()?;
         745  +
                    } else {
         746  +
                        builder.schedule_expression = Some(deser.read_string(member)?);
         747  +
                    }
         748  +
                }
         749  +
                Some(7) => {
         750  +
                    if deser.is_null() {
         751  +
                        deser.read_null()?;
         752  +
                    } else {
         753  +
                        builder.output_location = Some(crate::types::InstanceAssociationOutputLocation::deserialize(deser)?);
         754  +
                    }
         755  +
                }
         756  +
                Some(8) => {
         757  +
                    if deser.is_null() {
         758  +
                        deser.read_null()?;
         759  +
                    } else {
         760  +
                        builder.association_name = Some(deser.read_string(member)?);
         761  +
                    }
         762  +
                }
         763  +
                Some(9) => {
         764  +
                    if deser.is_null() {
         765  +
                        deser.read_null()?;
         766  +
                    } else {
         767  +
                        builder.max_errors = Some(deser.read_string(member)?);
         768  +
                    }
         769  +
                }
         770  +
                Some(10) => {
         771  +
                    if deser.is_null() {
         772  +
                        deser.read_null()?;
         773  +
                    } else {
         774  +
                        builder.max_concurrency = Some(deser.read_string(member)?);
         775  +
                    }
         776  +
                }
         777  +
                Some(11) => {
         778  +
                    if deser.is_null() {
         779  +
                        deser.read_null()?;
         780  +
                    } else {
         781  +
                        builder.compliance_severity = Some(crate::types::AssociationComplianceSeverity::from(deser.read_string(member)?.as_str()));
         782  +
                    }
         783  +
                }
         784  +
                Some(12) => {
         785  +
                    if deser.is_null() {
         786  +
                        deser.read_null()?;
         787  +
                    } else {
         788  +
                        builder.sync_compliance = Some(crate::types::AssociationSyncCompliance::from(deser.read_string(member)?.as_str()));
         789  +
                    }
         790  +
                }
         791  +
                Some(13) => {
         792  +
                    builder.apply_only_at_cron_interval = Some(deser.read_boolean(member)?);
         793  +
                }
         794  +
                Some(14) => {
         795  +
                    if deser.is_null() {
         796  +
                        deser.read_null()?;
         797  +
                    } else {
         798  +
                        builder.calendar_names = Some(deser.read_string_list(member)?);
         799  +
                    }
         800  +
                }
         801  +
                Some(15) => {
         802  +
                    if deser.is_null() {
         803  +
                        deser.read_null()?;
         804  +
                    } else {
         805  +
                        builder.target_locations = Some({
         806  +
                            let mut container = Vec::new();
         807  +
                            deser.read_list(member, &mut |deser| {
         808  +
                                container.push(crate::types::TargetLocation::deserialize(deser)?);
         809  +
                                Ok(())
         810  +
                            })?;
         811  +
                            container
         812  +
                        });
         813  +
                    }
         814  +
                }
         815  +
                Some(16) => {
         816  +
                    if deser.is_null() {
         817  +
                        deser.read_null()?;
         818  +
                    } else {
         819  +
                        builder.schedule_offset = Some(deser.read_integer(member)?);
         820  +
                    }
         821  +
                }
         822  +
                Some(17) => {
         823  +
                    if deser.is_null() {
         824  +
                        deser.read_null()?;
         825  +
                    } else {
         826  +
                        builder.duration = Some(deser.read_integer(member)?);
         827  +
                    }
         828  +
                }
         829  +
                Some(18) => {
         830  +
                    if deser.is_null() {
         831  +
                        deser.read_null()?;
         832  +
                    } else {
         833  +
                        builder.target_maps = Some({
         834  +
                            let mut container = Vec::new();
         835  +
                            deser.read_list(member, &mut |deser| {
         836  +
                                container.push({
         837  +
                                    let mut map = ::std::collections::HashMap::new();
         838  +
                                    deser.read_map(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER, &mut |key, deser| {
         839  +
                                        let value = {
         840  +
                                            let mut list = Vec::new();
         841  +
                                            deser.read_list(&CREATEASSOCIATIONBATCHREQUESTENTRY_MEMBER_TARGET_MAPS_MEMBER_VALUE, &mut |deser| {
         842  +
                                                list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
         843  +
                                                Ok(())
         844  +
                                            })?;
         845  +
                                            list
         846  +
                                        };
         847  +
                                        map.insert(key, value);
         848  +
                                        Ok(())
         849  +
                                    })?;
         850  +
                                    map
         851  +
                                });
         852  +
                                Ok(())
         853  +
                            })?;
         854  +
                            container
         855  +
                        });
         856  +
                    }
         857  +
                }
         858  +
                Some(19) => {
         859  +
                    if deser.is_null() {
         860  +
                        deser.read_null()?;
         861  +
                    } else {
         862  +
                        builder.alarm_configuration = Some(crate::types::AlarmConfiguration::deserialize(deser)?);
         863  +
                    }
         864  +
                }
         865  +
                _ => {}
         866  +
            }
         867  +
            Ok(())
         868  +
        })?;
         869  +
        builder.name = builder.name.or(Some(String::new()));
         870  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
         871  +
    }
         872  +
}
         873  +
impl CreateAssociationBatchRequestEntry {
         874  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         875  +
    pub fn deserialize_with_response(
         876  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         877  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         878  +
        _status: u16,
         879  +
        _body: &[u8],
         880  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         881  +
        Self::deserialize(deserializer)
         882  +
    }
         883  +
}
         884  +
impl CreateAssociationBatchRequestEntry {
         885  +
    /// Creates a new builder-style object to manufacture [`CreateAssociationBatchRequestEntry`](crate::types::CreateAssociationBatchRequestEntry).
         886  +
    pub fn builder() -> crate::types::builders::CreateAssociationBatchRequestEntryBuilder {
         887  +
        crate::types::builders::CreateAssociationBatchRequestEntryBuilder::default()
         888  +
    }
         889  +
}
         890  +
         891  +
/// A builder for [`CreateAssociationBatchRequestEntry`](crate::types::CreateAssociationBatchRequestEntry).
         892  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
         893  +
#[non_exhaustive]
         894  +
pub struct CreateAssociationBatchRequestEntryBuilder {
         895  +
    pub(crate) name: ::std::option::Option<::std::string::String>,
         896  +
    pub(crate) instance_id: ::std::option::Option<::std::string::String>,
         897  +
    pub(crate) parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
         898  +
    pub(crate) automation_target_parameter_name: ::std::option::Option<::std::string::String>,
         899  +
    pub(crate) document_version: ::std::option::Option<::std::string::String>,
         900  +
    pub(crate) targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
         901  +
    pub(crate) schedule_expression: ::std::option::Option<::std::string::String>,
         902  +
    pub(crate) output_location: ::std::option::Option<crate::types::InstanceAssociationOutputLocation>,
         903  +
    pub(crate) association_name: ::std::option::Option<::std::string::String>,
         904  +
    pub(crate) max_errors: ::std::option::Option<::std::string::String>,
         905  +
    pub(crate) max_concurrency: ::std::option::Option<::std::string::String>,
         906  +
    pub(crate) compliance_severity: ::std::option::Option<crate::types::AssociationComplianceSeverity>,
         907  +
    pub(crate) sync_compliance: ::std::option::Option<crate::types::AssociationSyncCompliance>,
         908  +
    pub(crate) apply_only_at_cron_interval: ::std::option::Option<bool>,
         909  +
    pub(crate) calendar_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         910  +
    pub(crate) target_locations: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>,
         911  +
    pub(crate) schedule_offset: ::std::option::Option<i32>,
         912  +
    pub(crate) duration: ::std::option::Option<i32>,
         913  +
    pub(crate) target_maps:
         914  +
        ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
         915  +
    pub(crate) alarm_configuration: ::std::option::Option<crate::types::AlarmConfiguration>,
         916  +
}
         917  +
impl CreateAssociationBatchRequestEntryBuilder {
         918  +
    /// <p>The name of the SSM document that contains the configuration information for the managed node. You can specify Command or Automation runbooks.</p>
         919  +
    /// <p>You can specify Amazon Web Services-predefined documents, documents you created, or a document that is shared with you from another account.</p>
         920  +
    /// <p>For SSM documents that are shared with you from other Amazon Web Services accounts, you must specify the complete SSM document ARN, in the following format:</p>
         921  +
    /// <p><code>arn:aws:ssm:<i>region</i>:<i>account-id</i>:document/<i>document-name</i> </code></p>
         922  +
    /// <p>For example:</p>
         923  +
    /// <p><code>arn:aws:ssm:us-east-2:12345678912:document/My-Shared-Document</code></p>
         924  +
    /// <p>For Amazon Web Services-predefined documents and SSM documents you created in your account, you only need to specify the document name. For example, <code>AWS-ApplyPatchBaseline</code> or <code>My-Document</code>.</p>
         925  +
    /// This field is required.
         926  +
    pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         927  +
        self.name = ::std::option::Option::Some(input.into());
         928  +
        self
         929  +
    }
         930  +
    /// <p>The name of the SSM document that contains the configuration information for the managed node. You can specify Command or Automation runbooks.</p>
         931  +
    /// <p>You can specify Amazon Web Services-predefined documents, documents you created, or a document that is shared with you from another account.</p>
         932  +
    /// <p>For SSM documents that are shared with you from other Amazon Web Services accounts, you must specify the complete SSM document ARN, in the following format:</p>
         933  +
    /// <p><code>arn:aws:ssm:<i>region</i>:<i>account-id</i>:document/<i>document-name</i> </code></p>
         934  +
    /// <p>For example:</p>
         935  +
    /// <p><code>arn:aws:ssm:us-east-2:12345678912:document/My-Shared-Document</code></p>
         936  +
    /// <p>For Amazon Web Services-predefined documents and SSM documents you created in your account, you only need to specify the document name. For example, <code>AWS-ApplyPatchBaseline</code> or <code>My-Document</code>.</p>
         937  +
    pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         938  +
        self.name = input;
         939  +
        self
         940  +
    }
         941  +
    /// <p>The name of the SSM document that contains the configuration information for the managed node. You can specify Command or Automation runbooks.</p>
         942  +
    /// <p>You can specify Amazon Web Services-predefined documents, documents you created, or a document that is shared with you from another account.</p>
         943  +
    /// <p>For SSM documents that are shared with you from other Amazon Web Services accounts, you must specify the complete SSM document ARN, in the following format:</p>
         944  +
    /// <p><code>arn:aws:ssm:<i>region</i>:<i>account-id</i>:document/<i>document-name</i> </code></p>
         945  +
    /// <p>For example:</p>
         946  +
    /// <p><code>arn:aws:ssm:us-east-2:12345678912:document/My-Shared-Document</code></p>
         947  +
    /// <p>For Amazon Web Services-predefined documents and SSM documents you created in your account, you only need to specify the document name. For example, <code>AWS-ApplyPatchBaseline</code> or <code>My-Document</code>.</p>
         948  +
    pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         949  +
        &self.name
         950  +
    }
         951  +
    /// <p>The managed node ID.</p><note>
         952  +
    /// <p><code>InstanceId</code> has been deprecated. To specify a managed node ID for an association, use the <code>Targets</code> parameter. Requests that include the parameter <code>InstanceID</code> with Systems Manager documents (SSM documents) that use schema version 2.0 or later will fail. In addition, if you use the parameter <code>InstanceId</code>, you can't use the parameters <code>AssociationName</code>, <code>DocumentVersion</code>, <code>MaxErrors</code>, <code>MaxConcurrency</code>, <code>OutputLocation</code>, or <code>ScheduleExpression</code>. To use these parameters, you must use the <code>Targets</code> parameter.</p>
         953  +
    /// </note>
         954  +
    pub fn instance_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         955  +
        self.instance_id = ::std::option::Option::Some(input.into());
         956  +
        self
         957  +
    }
         958  +
    /// <p>The managed node ID.</p><note>
         959  +
    /// <p><code>InstanceId</code> has been deprecated. To specify a managed node ID for an association, use the <code>Targets</code> parameter. Requests that include the parameter <code>InstanceID</code> with Systems Manager documents (SSM documents) that use schema version 2.0 or later will fail. In addition, if you use the parameter <code>InstanceId</code>, you can't use the parameters <code>AssociationName</code>, <code>DocumentVersion</code>, <code>MaxErrors</code>, <code>MaxConcurrency</code>, <code>OutputLocation</code>, or <code>ScheduleExpression</code>. To use these parameters, you must use the <code>Targets</code> parameter.</p>
         960  +
    /// </note>
         961  +
    pub fn set_instance_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         962  +
        self.instance_id = input;
         963  +
        self
         964  +
    }
         965  +
    /// <p>The managed node ID.</p><note>
         966  +
    /// <p><code>InstanceId</code> has been deprecated. To specify a managed node ID for an association, use the <code>Targets</code> parameter. Requests that include the parameter <code>InstanceID</code> with Systems Manager documents (SSM documents) that use schema version 2.0 or later will fail. In addition, if you use the parameter <code>InstanceId</code>, you can't use the parameters <code>AssociationName</code>, <code>DocumentVersion</code>, <code>MaxErrors</code>, <code>MaxConcurrency</code>, <code>OutputLocation</code>, or <code>ScheduleExpression</code>. To use these parameters, you must use the <code>Targets</code> parameter.</p>
         967  +
    /// </note>
         968  +
    pub fn get_instance_id(&self) -> &::std::option::Option<::std::string::String> {
         969  +
        &self.instance_id
         970  +
    }
         971  +
    /// Adds a key-value pair to `parameters`.
         972  +
    ///
         973  +
    /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
         974  +
    ///
         975  +
    /// <p>A description of the parameters for a document.</p>
         976  +
    pub fn parameters(mut self, k: impl ::std::convert::Into<::std::string::String>, v: ::std::vec::Vec<::std::string::String>) -> Self {
         977  +
        let mut hash_map = self.parameters.unwrap_or_default();
         978  +
        hash_map.insert(k.into(), v);
         979  +
        self.parameters = ::std::option::Option::Some(hash_map);
         980  +
        self
         981  +
    }
         982  +
    /// <p>A description of the parameters for a document.</p>
         983  +
    pub fn set_parameters(
         984  +
        mut self,
         985  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
         986  +
    ) -> Self {
         987  +
        self.parameters = input;
         988  +
        self
         989  +
    }
         990  +
    /// <p>A description of the parameters for a document.</p>
         991  +
    pub fn get_parameters(
         992  +
        &self,
         993  +
    ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         994  +
        &self.parameters
         995  +
    }
         996  +
    /// <p>Specify the target for the association. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in Amazon Web Services Systems Manager.</p>
         997  +
    pub fn automation_target_parameter_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         998  +
        self.automation_target_parameter_name = ::std::option::Option::Some(input.into());
         999  +
        self
        1000  +
    }
        1001  +
    /// <p>Specify the target for the association. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in Amazon Web Services Systems Manager.</p>
        1002  +
    pub fn set_automation_target_parameter_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1003  +
        self.automation_target_parameter_name = input;
        1004  +
        self
        1005  +
    }
        1006  +
    /// <p>Specify the target for the association. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in Amazon Web Services Systems Manager.</p>
        1007  +
    pub fn get_automation_target_parameter_name(&self) -> &::std::option::Option<::std::string::String> {
        1008  +
        &self.automation_target_parameter_name
        1009  +
    }
        1010  +
    /// <p>The document version.</p>
        1011  +
    pub fn document_version(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1012  +
        self.document_version = ::std::option::Option::Some(input.into());
        1013  +
        self
        1014  +
    }
        1015  +
    /// <p>The document version.</p>
        1016  +
    pub fn set_document_version(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1017  +
        self.document_version = input;
        1018  +
        self
        1019  +
    }
        1020  +
    /// <p>The document version.</p>
        1021  +
    pub fn get_document_version(&self) -> &::std::option::Option<::std::string::String> {
        1022  +
        &self.document_version
        1023  +
    }
        1024  +
    /// Appends an item to `targets`.
        1025  +
    ///
        1026  +
    /// To override the contents of this collection use [`set_targets`](Self::set_targets).
        1027  +
    ///
        1028  +
    /// <p>The managed nodes targeted by the request.</p>
        1029  +
    pub fn targets(mut self, input: crate::types::Target) -> Self {
        1030  +
        let mut v = self.targets.unwrap_or_default();
        1031  +
        v.push(input);
        1032  +
        self.targets = ::std::option::Option::Some(v);
        1033  +
        self
        1034  +
    }
        1035  +
    /// <p>The managed nodes targeted by the request.</p>
        1036  +
    pub fn set_targets(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Target>>) -> Self {
        1037  +
        self.targets = input;
        1038  +
        self
        1039  +
    }
        1040  +
    /// <p>The managed nodes targeted by the request.</p>
        1041  +
    pub fn get_targets(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Target>> {
        1042  +
        &self.targets
        1043  +
    }
        1044  +
    /// <p>A cron expression that specifies a schedule when the association runs.</p>
        1045  +
    pub fn schedule_expression(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1046  +
        self.schedule_expression = ::std::option::Option::Some(input.into());
        1047  +
        self
        1048  +
    }
        1049  +
    /// <p>A cron expression that specifies a schedule when the association runs.</p>
        1050  +
    pub fn set_schedule_expression(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1051  +
        self.schedule_expression = input;
        1052  +
        self
        1053  +
    }
        1054  +
    /// <p>A cron expression that specifies a schedule when the association runs.</p>
        1055  +
    pub fn get_schedule_expression(&self) -> &::std::option::Option<::std::string::String> {
        1056  +
        &self.schedule_expression
        1057  +
    }
        1058  +
    /// <p>An S3 bucket where you want to store the results of this request.</p>
        1059  +
    pub fn output_location(mut self, input: crate::types::InstanceAssociationOutputLocation) -> Self {
        1060  +
        self.output_location = ::std::option::Option::Some(input);
        1061  +
        self
        1062  +
    }
        1063  +
    /// <p>An S3 bucket where you want to store the results of this request.</p>
        1064  +
    pub fn set_output_location(mut self, input: ::std::option::Option<crate::types::InstanceAssociationOutputLocation>) -> Self {
        1065  +
        self.output_location = input;
        1066  +
        self
        1067  +
    }
        1068  +
    /// <p>An S3 bucket where you want to store the results of this request.</p>
        1069  +
    pub fn get_output_location(&self) -> &::std::option::Option<crate::types::InstanceAssociationOutputLocation> {
        1070  +
        &self.output_location
        1071  +
    }
        1072  +
    /// <p>Specify a descriptive name for the association.</p>
        1073  +
    pub fn association_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1074  +
        self.association_name = ::std::option::Option::Some(input.into());
        1075  +
        self
        1076  +
    }
        1077  +
    /// <p>Specify a descriptive name for the association.</p>
        1078  +
    pub fn set_association_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1079  +
        self.association_name = input;
        1080  +
        self
        1081  +
    }
        1082  +
    /// <p>Specify a descriptive name for the association.</p>
        1083  +
    pub fn get_association_name(&self) -> &::std::option::Option<::std::string::String> {
        1084  +
        &self.association_name
        1085  +
    }
        1086  +
    /// <p>The number of errors that are allowed before the system stops sending requests to run the association on additional targets. You can specify either an absolute number of errors, for example 10, or a percentage of the target set, for example 10%. If you specify 3, for example, the system stops sending requests when the fourth error is received. If you specify 0, then the system stops sending requests after the first error is returned. If you run an association on 50 managed nodes and set <code>MaxError</code> to 10%, then the system stops sending the request when the sixth error is received.</p>
        1087  +
    /// <p>Executions that are already running an association when <code>MaxErrors</code> is reached are allowed to complete, but some of these executions may fail as well. If you need to ensure that there won't be more than max-errors failed executions, set <code>MaxConcurrency</code> to 1 so that executions proceed one at a time.</p>
        1088  +
    pub fn max_errors(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1089  +
        self.max_errors = ::std::option::Option::Some(input.into());
        1090  +
        self
        1091  +
    }
        1092  +
    /// <p>The number of errors that are allowed before the system stops sending requests to run the association on additional targets. You can specify either an absolute number of errors, for example 10, or a percentage of the target set, for example 10%. If you specify 3, for example, the system stops sending requests when the fourth error is received. If you specify 0, then the system stops sending requests after the first error is returned. If you run an association on 50 managed nodes and set <code>MaxError</code> to 10%, then the system stops sending the request when the sixth error is received.</p>
        1093  +
    /// <p>Executions that are already running an association when <code>MaxErrors</code> is reached are allowed to complete, but some of these executions may fail as well. If you need to ensure that there won't be more than max-errors failed executions, set <code>MaxConcurrency</code> to 1 so that executions proceed one at a time.</p>
        1094  +
    pub fn set_max_errors(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1095  +
        self.max_errors = input;
        1096  +
        self
        1097  +
    }
        1098  +
    /// <p>The number of errors that are allowed before the system stops sending requests to run the association on additional targets. You can specify either an absolute number of errors, for example 10, or a percentage of the target set, for example 10%. If you specify 3, for example, the system stops sending requests when the fourth error is received. If you specify 0, then the system stops sending requests after the first error is returned. If you run an association on 50 managed nodes and set <code>MaxError</code> to 10%, then the system stops sending the request when the sixth error is received.</p>
        1099  +
    /// <p>Executions that are already running an association when <code>MaxErrors</code> is reached are allowed to complete, but some of these executions may fail as well. If you need to ensure that there won't be more than max-errors failed executions, set <code>MaxConcurrency</code> to 1 so that executions proceed one at a time.</p>
        1100  +
    pub fn get_max_errors(&self) -> &::std::option::Option<::std::string::String> {
        1101  +
        &self.max_errors
        1102  +
    }
        1103  +
    /// <p>The maximum number of targets allowed to run the association at the same time. You can specify a number, for example 10, or a percentage of the target set, for example 10%. The default value is 100%, which means all targets run the association at the same time.</p>
        1104  +
    /// <p>If a new managed node starts and attempts to run an association while Systems Manager is running <code>MaxConcurrency</code> associations, the association is allowed to run. During the next association interval, the new managed node will process its association within the limit specified for <code>MaxConcurrency</code>.</p>
        1105  +
    pub fn max_concurrency(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1106  +
        self.max_concurrency = ::std::option::Option::Some(input.into());
        1107  +
        self
        1108  +
    }
        1109  +
    /// <p>The maximum number of targets allowed to run the association at the same time. You can specify a number, for example 10, or a percentage of the target set, for example 10%. The default value is 100%, which means all targets run the association at the same time.</p>
        1110  +
    /// <p>If a new managed node starts and attempts to run an association while Systems Manager is running <code>MaxConcurrency</code> associations, the association is allowed to run. During the next association interval, the new managed node will process its association within the limit specified for <code>MaxConcurrency</code>.</p>
        1111  +
    pub fn set_max_concurrency(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        1112  +
        self.max_concurrency = input;
        1113  +
        self
        1114  +
    }
        1115  +
    /// <p>The maximum number of targets allowed to run the association at the same time. You can specify a number, for example 10, or a percentage of the target set, for example 10%. The default value is 100%, which means all targets run the association at the same time.</p>
        1116  +
    /// <p>If a new managed node starts and attempts to run an association while Systems Manager is running <code>MaxConcurrency</code> associations, the association is allowed to run. During the next association interval, the new managed node will process its association within the limit specified for <code>MaxConcurrency</code>.</p>
        1117  +
    pub fn get_max_concurrency(&self) -> &::std::option::Option<::std::string::String> {
        1118  +
        &self.max_concurrency
        1119  +
    }
        1120  +
    /// <p>The severity level to assign to the association.</p>
        1121  +
    pub fn compliance_severity(mut self, input: crate::types::AssociationComplianceSeverity) -> Self {
        1122  +
        self.compliance_severity = ::std::option::Option::Some(input);
        1123  +
        self
        1124  +
    }
        1125  +
    /// <p>The severity level to assign to the association.</p>
        1126  +
    pub fn set_compliance_severity(mut self, input: ::std::option::Option<crate::types::AssociationComplianceSeverity>) -> Self {
        1127  +
        self.compliance_severity = input;
        1128  +
        self
        1129  +
    }
        1130  +
    /// <p>The severity level to assign to the association.</p>
        1131  +
    pub fn get_compliance_severity(&self) -> &::std::option::Option<crate::types::AssociationComplianceSeverity> {
        1132  +
        &self.compliance_severity
        1133  +
    }
        1134  +
    /// <p>The mode for generating association compliance. You can specify <code>AUTO</code> or <code>MANUAL</code>. In <code>AUTO</code> mode, the system uses the status of the association execution to determine the compliance status. If the association execution runs successfully, then the association is <code>COMPLIANT</code>. If the association execution doesn't run successfully, the association is <code>NON-COMPLIANT</code>.</p>
        1135  +
    /// <p>In <code>MANUAL</code> mode, you must specify the <code>AssociationId</code> as a parameter for the <code>PutComplianceItems</code> API operation. In this case, compliance data isn't managed by State Manager, a tool in Amazon Web Services Systems Manager. It is managed by your direct call to the <code>PutComplianceItems</code> API operation.</p>
        1136  +
    /// <p>By default, all associations use <code>AUTO</code> mode.</p>
        1137  +
    pub fn sync_compliance(mut self, input: crate::types::AssociationSyncCompliance) -> Self {
        1138  +
        self.sync_compliance = ::std::option::Option::Some(input);
        1139  +
        self
        1140  +
    }
        1141  +
    /// <p>The mode for generating association compliance. You can specify <code>AUTO</code> or <code>MANUAL</code>. In <code>AUTO</code> mode, the system uses the status of the association execution to determine the compliance status. If the association execution runs successfully, then the association is <code>COMPLIANT</code>. If the association execution doesn't run successfully, the association is <code>NON-COMPLIANT</code>.</p>
        1142  +
    /// <p>In <code>MANUAL</code> mode, you must specify the <code>AssociationId</code> as a parameter for the <code>PutComplianceItems</code> API operation. In this case, compliance data isn't managed by State Manager, a tool in Amazon Web Services Systems Manager. It is managed by your direct call to the <code>PutComplianceItems</code> API operation.</p>
        1143  +
    /// <p>By default, all associations use <code>AUTO</code> mode.</p>
        1144  +
    pub fn set_sync_compliance(mut self, input: ::std::option::Option<crate::types::AssociationSyncCompliance>) -> Self {
        1145  +
        self.sync_compliance = input;
        1146  +
        self
        1147  +
    }
        1148  +
    /// <p>The mode for generating association compliance. You can specify <code>AUTO</code> or <code>MANUAL</code>. In <code>AUTO</code> mode, the system uses the status of the association execution to determine the compliance status. If the association execution runs successfully, then the association is <code>COMPLIANT</code>. If the association execution doesn't run successfully, the association is <code>NON-COMPLIANT</code>.</p>
        1149  +
    /// <p>In <code>MANUAL</code> mode, you must specify the <code>AssociationId</code> as a parameter for the <code>PutComplianceItems</code> API operation. In this case, compliance data isn't managed by State Manager, a tool in Amazon Web Services Systems Manager. It is managed by your direct call to the <code>PutComplianceItems</code> API operation.</p>
        1150  +
    /// <p>By default, all associations use <code>AUTO</code> mode.</p>
        1151  +
    pub fn get_sync_compliance(&self) -> &::std::option::Option<crate::types::AssociationSyncCompliance> {
        1152  +
        &self.sync_compliance
        1153  +
    }
        1154  +
    /// <p>By default, when you create a new association, the system runs it immediately after it is created and then according to the schedule you specified and when target changes are detected. Specify <code>true</code> for <code>ApplyOnlyAtCronInterval</code> if you want the association to run only according to the schedule you specified.</p>
        1155  +
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#state-manager-about-scheduling">Understanding when associations are applied to resources</a> and <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#runbook-target-updates">&gt;About target updates with Automation runbooks</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1156  +
    /// <p>This parameter isn't supported for rate expressions.</p>
        1157  +
    pub fn apply_only_at_cron_interval(mut self, input: bool) -> Self {
        1158  +
        self.apply_only_at_cron_interval = ::std::option::Option::Some(input);
        1159  +
        self
        1160  +
    }
        1161  +
    /// <p>By default, when you create a new association, the system runs it immediately after it is created and then according to the schedule you specified and when target changes are detected. Specify <code>true</code> for <code>ApplyOnlyAtCronInterval</code> if you want the association to run only according to the schedule you specified.</p>
        1162  +
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#state-manager-about-scheduling">Understanding when associations are applied to resources</a> and <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#runbook-target-updates">&gt;About target updates with Automation runbooks</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1163  +
    /// <p>This parameter isn't supported for rate expressions.</p>
        1164  +
    pub fn set_apply_only_at_cron_interval(mut self, input: ::std::option::Option<bool>) -> Self {
        1165  +
        self.apply_only_at_cron_interval = input;
        1166  +
        self
        1167  +
    }
        1168  +
    /// <p>By default, when you create a new association, the system runs it immediately after it is created and then according to the schedule you specified and when target changes are detected. Specify <code>true</code> for <code>ApplyOnlyAtCronInterval</code> if you want the association to run only according to the schedule you specified.</p>
        1169  +
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#state-manager-about-scheduling">Understanding when associations are applied to resources</a> and <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/state-manager-about.html#runbook-target-updates">&gt;About target updates with Automation runbooks</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1170  +
    /// <p>This parameter isn't supported for rate expressions.</p>
        1171  +
    pub fn get_apply_only_at_cron_interval(&self) -> &::std::option::Option<bool> {
        1172  +
        &self.apply_only_at_cron_interval
        1173  +
    }
        1174  +
    /// Appends an item to `calendar_names`.
        1175  +
    ///
        1176  +
    /// To override the contents of this collection use [`set_calendar_names`](Self::set_calendar_names).
        1177  +
    ///
        1178  +
    /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar">Amazon Web Services Systems Manager Change Calendar</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1179  +
    pub fn calendar_names(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
        1180  +
        let mut v = self.calendar_names.unwrap_or_default();
        1181  +
        v.push(input.into());
        1182  +
        self.calendar_names = ::std::option::Option::Some(v);
        1183  +
        self
        1184  +
    }
        1185  +
    /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar">Amazon Web Services Systems Manager Change Calendar</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1186  +
    pub fn set_calendar_names(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
        1187  +
        self.calendar_names = input;
        1188  +
        self
        1189  +
    }
        1190  +
    /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar">Amazon Web Services Systems Manager Change Calendar</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
        1191  +
    pub fn get_calendar_names(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
        1192  +
        &self.calendar_names
        1193  +
    }
        1194  +
    /// Appends an item to `target_locations`.
        1195  +
    ///
        1196  +
    /// To override the contents of this collection use [`set_target_locations`](Self::set_target_locations).
        1197  +
    ///
        1198  +
    /// <p>Use this action to create an association in multiple Regions and multiple accounts.</p>
        1199  +
    pub fn target_locations(mut self, input: crate::types::TargetLocation) -> Self {
        1200  +
        let mut v = self.target_locations.unwrap_or_default();
        1201  +
        v.push(input);
        1202  +
        self.target_locations = ::std::option::Option::Some(v);
        1203  +
        self
        1204  +
    }
        1205  +
    /// <p>Use this action to create an association in multiple Regions and multiple accounts.</p>
        1206  +
    pub fn set_target_locations(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>) -> Self {
        1207  +
        self.target_locations = input;
        1208  +
        self
        1209  +
    }
        1210  +
    /// <p>Use this action to create an association in multiple Regions and multiple accounts.</p>
        1211  +
    pub fn get_target_locations(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>> {
        1212  +
        &self.target_locations
        1213  +
    }
        1214  +
    /// <p>Number of days to wait after the scheduled day to run an association.</p>
        1215  +
    pub fn schedule_offset(mut self, input: i32) -> Self {
        1216  +
        self.schedule_offset = ::std::option::Option::Some(input);
        1217  +
        self
        1218  +
    }
        1219  +
    /// <p>Number of days to wait after the scheduled day to run an association.</p>
        1220  +
    pub fn set_schedule_offset(mut self, input: ::std::option::Option<i32>) -> Self {
        1221  +
        self.schedule_offset = input;
        1222  +
        self
        1223  +
    }
        1224  +
    /// <p>Number of days to wait after the scheduled day to run an association.</p>
        1225  +
    pub fn get_schedule_offset(&self) -> &::std::option::Option<i32> {
        1226  +
        &self.schedule_offset
        1227  +
    }
        1228  +
    /// <p>The number of hours the association can run before it is canceled. Duration applies to associations that are currently running, and any pending and in progress commands on all targets. If a target was taken offline for the association to run, it is made available again immediately, without a reboot.</p>
        1229  +
    /// <p>The <code>Duration</code> parameter applies only when both these conditions are true:</p>
        1230  +
    /// <ul>
        1231  +
    /// <li>
        1232  +
    /// <p>The association for which you specify a duration is cancelable according to the parameters of the SSM command document or Automation runbook associated with this execution.</p></li>
        1233  +
    /// <li>
        1234  +
    /// <p>The command specifies the <code> <a href="https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateAssociationBatchRequestEntry.html#systemsmanager-Type-CreateAssociationBatchRequestEntry-ApplyOnlyAtCronInterval">ApplyOnlyAtCronInterval</a> </code> parameter, which means that the association doesn't run immediately after it is created, but only according to the specified schedule.</p></li>
        1235  +
    /// </ul>
        1236  +
    pub fn duration(mut self, input: i32) -> Self {
        1237  +
        self.duration = ::std::option::Option::Some(input);
        1238  +
        self
        1239  +
    }
        1240  +
    /// <p>The number of hours the association can run before it is canceled. Duration applies to associations that are currently running, and any pending and in progress commands on all targets. If a target was taken offline for the association to run, it is made available again immediately, without a reboot.</p>
        1241  +
    /// <p>The <code>Duration</code> parameter applies only when both these conditions are true:</p>
        1242  +
    /// <ul>
        1243  +
    /// <li>
        1244  +
    /// <p>The association for which you specify a duration is cancelable according to the parameters of the SSM command document or Automation runbook associated with this execution.</p></li>
        1245  +
    /// <li>
        1246  +
    /// <p>The command specifies the <code> <a href="https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateAssociationBatchRequestEntry.html#systemsmanager-Type-CreateAssociationBatchRequestEntry-ApplyOnlyAtCronInterval">ApplyOnlyAtCronInterval</a> </code> parameter, which means that the association doesn't run immediately after it is created, but only according to the specified schedule.</p></li>
        1247  +
    /// </ul>
        1248  +
    pub fn set_duration(mut self, input: ::std::option::Option<i32>) -> Self {
        1249  +
        self.duration = input;
        1250  +
        self
        1251  +
    }
        1252  +
    /// <p>The number of hours the association can run before it is canceled. Duration applies to associations that are currently running, and any pending and in progress commands on all targets. If a target was taken offline for the association to run, it is made available again immediately, without a reboot.</p>
        1253  +
    /// <p>The <code>Duration</code> parameter applies only when both these conditions are true:</p>
        1254  +
    /// <ul>
        1255  +
    /// <li>
        1256  +
    /// <p>The association for which you specify a duration is cancelable according to the parameters of the SSM command document or Automation runbook associated with this execution.</p></li>
        1257  +
    /// <li>
        1258  +
    /// <p>The command specifies the <code> <a href="https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateAssociationBatchRequestEntry.html#systemsmanager-Type-CreateAssociationBatchRequestEntry-ApplyOnlyAtCronInterval">ApplyOnlyAtCronInterval</a> </code> parameter, which means that the association doesn't run immediately after it is created, but only according to the specified schedule.</p></li>
        1259  +
    /// </ul>
        1260  +
    pub fn get_duration(&self) -> &::std::option::Option<i32> {
        1261  +
        &self.duration
        1262  +
    }
        1263  +
    /// Appends an item to `target_maps`.
        1264  +
    ///
        1265  +
    /// To override the contents of this collection use [`set_target_maps`](Self::set_target_maps).
        1266  +
    ///
        1267  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
        1268  +
    pub fn target_maps(mut self, input: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>) -> Self {
        1269  +
        let mut v = self.target_maps.unwrap_or_default();
        1270  +
        v.push(input);
        1271  +
        self.target_maps = ::std::option::Option::Some(v);
        1272  +
        self
        1273  +
    }
        1274  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
        1275  +
    pub fn set_target_maps(
        1276  +
        mut self,
        1277  +
        input: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
        1278  +
    ) -> Self {
        1279  +
        self.target_maps = input;
        1280  +
        self
        1281  +
    }
        1282  +
    /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
        1283  +
    pub fn get_target_maps(
        1284  +
        &self,
        1285  +
    ) -> &::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>> {
        1286  +
        &self.target_maps
        1287  +
    }
        1288  +
    /// <p>The details for the CloudWatch alarm you want to apply to an automation or command.</p>
        1289  +
    pub fn alarm_configuration(mut self, input: crate::types::AlarmConfiguration) -> Self {
        1290  +
        self.alarm_configuration = ::std::option::Option::Some(input);
        1291  +
        self
        1292  +
    }
        1293  +
    /// <p>The details for the CloudWatch alarm you want to apply to an automation or command.</p>
        1294  +
    pub fn set_alarm_configuration(mut self, input: ::std::option::Option<crate::types::AlarmConfiguration>) -> Self {
        1295  +
        self.alarm_configuration = input;
        1296  +
        self
        1297  +
    }
        1298  +
    /// <p>The details for the CloudWatch alarm you want to apply to an automation or command.</p>
        1299  +
    pub fn get_alarm_configuration(&self) -> &::std::option::Option<crate::types::AlarmConfiguration> {
        1300  +
        &self.alarm_configuration
        1301  +
    }
        1302  +
    /// Consumes the builder and constructs a [`CreateAssociationBatchRequestEntry`](crate::types::CreateAssociationBatchRequestEntry).
        1303  +
    /// This method will fail if any of the following fields are not set:
        1304  +
    /// - [`name`](crate::types::builders::CreateAssociationBatchRequestEntryBuilder::name)
        1305  +
    pub fn build(self) -> ::std::result::Result<crate::types::CreateAssociationBatchRequestEntry, ::aws_smithy_types::error::operation::BuildError> {
        1306  +
        ::std::result::Result::Ok(crate::types::CreateAssociationBatchRequestEntry {
        1307  +
            name: self.name.ok_or_else(|| {
        1308  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
        1309  +
                    "name",
        1310  +
                    "name was not specified but it is required when building CreateAssociationBatchRequestEntry",
        1311  +
                )
        1312  +
            })?,
        1313  +
            instance_id: self.instance_id,
        1314  +
            parameters: self.parameters,
        1315  +
            automation_target_parameter_name: self.automation_target_parameter_name,
        1316  +
            document_version: self.document_version,
        1317  +
            targets: self.targets,
        1318  +
            schedule_expression: self.schedule_expression,
        1319  +
            output_location: self.output_location,
        1320  +
            association_name: self.association_name,
        1321  +
            max_errors: self.max_errors,
        1322  +
            max_concurrency: self.max_concurrency,
        1323  +
            compliance_severity: self.compliance_severity,
        1324  +
            sync_compliance: self.sync_compliance,
        1325  +
            apply_only_at_cron_interval: self.apply_only_at_cron_interval.unwrap_or_default(),
        1326  +
            calendar_names: self.calendar_names,
        1327  +
            target_locations: self.target_locations,
        1328  +
            schedule_offset: self.schedule_offset,
        1329  +
            duration: self.duration,
        1330  +
            target_maps: self.target_maps,
        1331  +
            alarm_configuration: self.alarm_configuration,
        1332  +
        })
        1333  +
    }
        1334  +
}
        1335  +
impl ::std::fmt::Debug for CreateAssociationBatchRequestEntryBuilder {
        1336  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        1337  +
        let mut formatter = f.debug_struct("CreateAssociationBatchRequestEntryBuilder");
        1338  +
        formatter.field("name", &self.name);
        1339  +
        formatter.field("instance_id", &self.instance_id);
        1340  +
        formatter.field("parameters", &"*** Sensitive Data Redacted ***");
        1341  +
        formatter.field("automation_target_parameter_name", &self.automation_target_parameter_name);
        1342  +
        formatter.field("document_version", &self.document_version);
        1343  +
        formatter.field("targets", &self.targets);
        1344  +
        formatter.field("schedule_expression", &self.schedule_expression);
        1345  +
        formatter.field("output_location", &self.output_location);
        1346  +
        formatter.field("association_name", &self.association_name);
        1347  +
        formatter.field("max_errors", &self.max_errors);
        1348  +
        formatter.field("max_concurrency", &self.max_concurrency);
        1349  +
        formatter.field("compliance_severity", &self.compliance_severity);
        1350  +
        formatter.field("sync_compliance", &self.sync_compliance);
        1351  +
        formatter.field("apply_only_at_cron_interval", &self.apply_only_at_cron_interval);
        1352  +
        formatter.field("calendar_names", &self.calendar_names);
        1353  +
        formatter.field("target_locations", &self.target_locations);
        1354  +
        formatter.field("schedule_offset", &self.schedule_offset);
        1355  +
        formatter.field("duration", &self.duration);
        1356  +
        formatter.field("target_maps", &self.target_maps);
        1357  +
        formatter.field("alarm_configuration", &self.alarm_configuration);
        1358  +
        formatter.finish()
        1359  +
    }
        1360  +
}