AWS SDK

AWS SDK

rev. bbca34fa2eddb4be623fbbc6b6df1a2401de0029 (ignoring whitespace)

Files changed:

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

@@ -0,1 +0,257 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// <p>Describes an association status.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct AssociationStatus {
     /// <p>The date when the status changed.</p>
     pub date: ::aws_smithy_types::DateTime,
     /// <p>The status.</p>
     pub name: crate::types::AssociationStatusName,
     /// <p>The reason for the status.</p>
     pub message: ::std::string::String,
     /// <p>A user-defined string.</p>
     pub additional_info: ::std::option::Option<::std::string::String>,
-+
+}
 impl AssociationStatus {
     /// <p>The date when the status changed.</p>
     pub fn date(&self) -> &::aws_smithy_types::DateTime {
         &self.date
-+
+    }
     /// <p>The status.</p>
     pub fn name(&self) -> &crate::types::AssociationStatusName {
         &self.name
-+
+    }
     /// <p>The reason for the status.</p>
     pub fn message(&self) -> &str {
         use std::ops::Deref;
         self.message.deref()
-+
+    }
     /// <p>A user-defined string.</p>
     pub fn additional_info(&self) -> ::std::option::Option<&str> {
         self.additional_info.as_deref()
-+
+    }
-+
+}
 static ASSOCIATIONSTATUS_MEMBER_DATE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationStatus$Date", "com.amazonaws.ssm", "AssociationStatus"),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "Date",
 ,
 );
 static ASSOCIATIONSTATUS_MEMBER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationStatus$Name", "com.amazonaws.ssm", "AssociationStatus"),
     ::aws_smithy_schema::ShapeType::String,
     "Name",
 ,
 );
 static ASSOCIATIONSTATUS_MEMBER_MESSAGE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationStatus$Message", "com.amazonaws.ssm", "AssociationStatus"),
     ::aws_smithy_schema::ShapeType::String,
     "Message",
 ,
 );
 static ASSOCIATIONSTATUS_MEMBER_ADDITIONAL_INFO: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationStatus$AdditionalInfo",
         "com.amazonaws.ssm",
         "AssociationStatus",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "AdditionalInfo",
 ,
 );
 static ASSOCIATIONSTATUS_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationStatus", "com.amazonaws.ssm", "AssociationStatus"),
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ASSOCIATIONSTATUS_MEMBER_DATE,
         &ASSOCIATIONSTATUS_MEMBER_NAME,
         &ASSOCIATIONSTATUS_MEMBER_MESSAGE,
         &ASSOCIATIONSTATUS_MEMBER_ADDITIONAL_INFO,
     ],
 );
 impl AssociationStatus {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &ASSOCIATIONSTATUS_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AssociationStatus {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
-+
+        {
             let val = &self.date;
             ser.write_timestamp(&ASSOCIATIONSTATUS_MEMBER_DATE, val)?;
-+
+        }
-+
+        {
             let val = &self.name;
             ser.write_string(&ASSOCIATIONSTATUS_MEMBER_NAME, val.as_str())?;
-+
+        }
-+
+        {
             let val = &self.message;
             ser.write_string(&ASSOCIATIONSTATUS_MEMBER_MESSAGE, val)?;
-+
+        }
         if let Some(ref val) = self.additional_info {
             ser.write_string(&ASSOCIATIONSTATUS_MEMBER_ADDITIONAL_INFO, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl AssociationStatus {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&ASSOCIATIONSTATUS_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.date = Some(deser.read_timestamp(member)?);
-+
+                }
                 Some(1) => {
                     builder.name = Some(crate::types::AssociationStatusName::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(2) => {
                     builder.message = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.additional_info = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.date = builder.date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         builder.message = builder.message.or(Some(String::new()));
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl AssociationStatus {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl AssociationStatus {
     /// Creates a new builder-style object to manufacture [`AssociationStatus`](crate::types::AssociationStatus).
     pub fn builder() -> crate::types::builders::AssociationStatusBuilder {
         crate::types::builders::AssociationStatusBuilder::default()
-+
+    }
-+
+}
-+
 /// A builder for [`AssociationStatus`](crate::types::AssociationStatus).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct AssociationStatusBuilder {
     pub(crate) date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) name: ::std::option::Option<crate::types::AssociationStatusName>,
     pub(crate) message: ::std::option::Option<::std::string::String>,
     pub(crate) additional_info: ::std::option::Option<::std::string::String>,
-+
+}
 impl AssociationStatusBuilder {
     /// <p>The date when the status changed.</p>
     /// This field is required.
     pub fn date(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.date = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The date when the status changed.</p>
     pub fn set_date(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.date = input;
         self
-+
+    }
     /// <p>The date when the status changed.</p>
     pub fn get_date(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         &self.date
-+
+    }
     /// <p>The status.</p>
     /// This field is required.
     pub fn name(mut self, input: crate::types::AssociationStatusName) -> Self {
         self.name = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The status.</p>
     pub fn set_name(mut self, input: ::std::option::Option<crate::types::AssociationStatusName>) -> Self {
         self.name = input;
         self
-+
+    }
     /// <p>The status.</p>
     pub fn get_name(&self) -> &::std::option::Option<crate::types::AssociationStatusName> {
         &self.name
-+
+    }
     /// <p>The reason for the status.</p>
     /// This field is required.
     pub fn message(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.message = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The reason for the status.</p>
     pub fn set_message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.message = input;
         self
-+
+    }
     /// <p>The reason for the status.</p>
     pub fn get_message(&self) -> &::std::option::Option<::std::string::String> {
         &self.message
-+
+    }
     /// <p>A user-defined string.</p>
     pub fn additional_info(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.additional_info = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>A user-defined string.</p>
     pub fn set_additional_info(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.additional_info = input;
         self
-+
+    }
     /// <p>A user-defined string.</p>
     pub fn get_additional_info(&self) -> &::std::option::Option<::std::string::String> {
         &self.additional_info
-+
+    }
     /// Consumes the builder and constructs a [`AssociationStatus`](crate::types::AssociationStatus).
     /// This method will fail if any of the following fields are not set:
     /// - [`date`](crate::types::builders::AssociationStatusBuilder::date)
     /// - [`name`](crate::types::builders::AssociationStatusBuilder::name)
     /// - [`message`](crate::types::builders::AssociationStatusBuilder::message)
     pub fn build(self) -> ::std::result::Result<crate::types::AssociationStatus, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::types::AssociationStatus {
             date: self.date.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "date",
                     "date was not specified but it is required when building AssociationStatus",
-+
+                )
             })?,
             name: self.name.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "name",
                     "name was not specified but it is required when building AssociationStatus",
-+
+                )
             })?,
             message: self.message.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "message",
                     "message was not specified but it is required when building AssociationStatus",
-+
+                )
             })?,
             additional_info: self.additional_info,
         })
-+
+    }
-+
+}

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

@@ -0,1 +0,114 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// When writing a match expression against `AssociationStatusName`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let associationstatusname = unimplemented!();
 /// match associationstatusname {
 ///     AssociationStatusName::Failed => { /* ... */ },
 ///     AssociationStatusName::Pending => { /* ... */ },
 ///     AssociationStatusName::Success => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `associationstatusname` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `AssociationStatusName::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `AssociationStatusName::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `AssociationStatusName::NewFeature` is defined.
 /// Specifically, when `associationstatusname` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `AssociationStatusName::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum AssociationStatusName {
     #[allow(missing_docs)] // documentation missing in model
     Failed,
     #[allow(missing_docs)] // documentation missing in model
     Pending,
     #[allow(missing_docs)] // documentation missing in model
     Success,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
-+
+}
 impl ::std::convert::From<&str> for AssociationStatusName {
     fn from(s: &str) -> Self {
         match s {
             "Failed" => AssociationStatusName::Failed,
             "Pending" => AssociationStatusName::Pending,
             "Success" => AssociationStatusName::Success,
             other => AssociationStatusName::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
-+
+        }
-+
+    }
-+
+}
 impl ::std::str::FromStr for AssociationStatusName {
     type Err = ::std::convert::Infallible;
-+
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(AssociationStatusName::from(s))
-+
+    }
-+
+}
 impl AssociationStatusName {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             AssociationStatusName::Failed => "Failed",
             AssociationStatusName::Pending => "Pending",
             AssociationStatusName::Success => "Success",
             AssociationStatusName::Unknown(value) => value.as_str(),
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["Failed", "Pending", "Success"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for AssociationStatusName {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl AssociationStatusName {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
-+
+        }
-+
+    }
-+
+}
 impl ::std::fmt::Display for AssociationStatusName {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             AssociationStatusName::Failed => write!(f, "Failed"),
             AssociationStatusName::Pending => write!(f, "Pending"),
             AssociationStatusName::Success => write!(f, "Success"),
             AssociationStatusName::Unknown(value) => write!(f, "{value}"),
-+
+        }
-+
+    }
-+
+}

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

@@ -0,1 +0,108 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// When writing a match expression against `AssociationSyncCompliance`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let associationsynccompliance = unimplemented!();
 /// match associationsynccompliance {
 ///     AssociationSyncCompliance::Auto => { /* ... */ },
 ///     AssociationSyncCompliance::Manual => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `associationsynccompliance` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `AssociationSyncCompliance::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `AssociationSyncCompliance::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `AssociationSyncCompliance::NewFeature` is defined.
 /// Specifically, when `associationsynccompliance` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `AssociationSyncCompliance::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum AssociationSyncCompliance {
     #[allow(missing_docs)] // documentation missing in model
     Auto,
     #[allow(missing_docs)] // documentation missing in model
     Manual,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
-+
+}
 impl ::std::convert::From<&str> for AssociationSyncCompliance {
     fn from(s: &str) -> Self {
         match s {
             "AUTO" => AssociationSyncCompliance::Auto,
             "MANUAL" => AssociationSyncCompliance::Manual,
             other => AssociationSyncCompliance::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
-+
+        }
-+
+    }
-+
+}
 impl ::std::str::FromStr for AssociationSyncCompliance {
     type Err = ::std::convert::Infallible;
-+
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(AssociationSyncCompliance::from(s))
-+
+    }
-+
+}
 impl AssociationSyncCompliance {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             AssociationSyncCompliance::Auto => "AUTO",
             AssociationSyncCompliance::Manual => "MANUAL",
             AssociationSyncCompliance::Unknown(value) => value.as_str(),
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["AUTO", "MANUAL"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for AssociationSyncCompliance {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl AssociationSyncCompliance {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
-+
+        }
-+
+    }
-+
+}
 impl ::std::fmt::Display for AssociationSyncCompliance {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             AssociationSyncCompliance::Auto => write!(f, "AUTO"),
             AssociationSyncCompliance::Manual => write!(f, "MANUAL"),
             AssociationSyncCompliance::Unknown(value) => write!(f, "{value}"),
-+
+        }
-+
+    }
-+
+}

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

@@ -0,1 +0,1301 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// <p>Information about the association version.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq)]
 pub struct AssociationVersionInfo {
     /// <p>The ID created by the system when the association was created.</p>
     pub association_id: ::std::option::Option<::std::string::String>,
     /// <p>The association version.</p>
     pub association_version: ::std::option::Option<::std::string::String>,
     /// <p>The date the association version was created.</p>
     pub created_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     /// <p>The name specified when the association was created.</p>
     pub name: ::std::option::Option<::std::string::String>,
     /// <p>The version of an Amazon Web Services Systems Manager document (SSM document) used when the association version was created.</p>
     pub document_version: ::std::option::Option<::std::string::String>,
     /// <p>Parameters specified when the association version was created.</p>
     pub parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
     /// <p>The targets specified for the association when the association version was created.</p>
     pub targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
     /// <p>The cron or rate schedule specified for the association when the association version was created.</p>
     pub schedule_expression: ::std::option::Option<::std::string::String>,
     /// <p>The location in Amazon S3 specified for the association when the association version was created.</p>
     pub output_location: ::std::option::Option<crate::types::InstanceAssociationOutputLocation>,
     /// <p>The name specified for the association version when the association version was created.</p>
     pub association_name: ::std::option::Option<::std::string::String>,
     /// <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>
     /// <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>
     pub max_errors: ::std::option::Option<::std::string::String>,
     /// <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>
     /// <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>
     pub max_concurrency: ::std::option::Option<::std::string::String>,
     /// <p>The severity level that is assigned to the association.</p>
     pub compliance_severity: ::std::option::Option<crate::types::AssociationComplianceSeverity>,
     /// <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>
     /// <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>
     /// <p>By default, all associations use <code>AUTO</code> mode.</p>
     pub sync_compliance: ::std::option::Option<crate::types::AssociationSyncCompliance>,
     /// <p>By default, when you create new associations, the system runs it immediately after it is created and then according to the schedule you specified. Specify this option if you don't want an association to run immediately after you create it. This parameter isn't supported for rate expressions.</p>
     pub apply_only_at_cron_interval: bool,
     /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations for this version 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>
     pub calendar_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts where you wanted to run the association when this association version was created.</p>
     pub target_locations: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>,
     /// <p>Number of days to wait after the scheduled day to run an association.</p>
     pub schedule_offset: ::std::option::Option<i32>,
     /// <p>The number of hours that an association can run on specified targets. After the resulting cutoff time passes, associations that are currently running are cancelled, and no pending executions are started on remaining targets.</p>
     pub duration: ::std::option::Option<i32>,
     /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
     pub target_maps:
         ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
     /// <p>A role used by association to take actions on your behalf. State Manager will assume this role and call required APIs when dispatching configurations to nodes. If not specified, <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/using-service-linked-roles.html"> service-linked role for Systems Manager</a> will be used by default.</p>
     pub association_dispatch_assume_role: ::std::option::Option<::std::string::String>,
-+
+}
 impl AssociationVersionInfo {
     /// <p>The ID created by the system when the association was created.</p>
     pub fn association_id(&self) -> ::std::option::Option<&str> {
         self.association_id.as_deref()
-+
+    }
     /// <p>The association version.</p>
     pub fn association_version(&self) -> ::std::option::Option<&str> {
         self.association_version.as_deref()
-+
+    }
     /// <p>The date the association version was created.</p>
     pub fn created_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.created_date.as_ref()
-+
+    }
     /// <p>The name specified when the association was created.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-+
+    }
     /// <p>The version of an Amazon Web Services Systems Manager document (SSM document) used when the association version was created.</p>
     pub fn document_version(&self) -> ::std::option::Option<&str> {
         self.document_version.as_deref()
-+
+    }
     /// <p>Parameters specified when the association version was created.</p>
     pub fn parameters(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         self.parameters.as_ref()
-+
+    }
     /// <p>The targets specified for the association when the association version was created.</p>
     ///
     /// 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()`.
     pub fn targets(&self) -> &[crate::types::Target] {
         self.targets.as_deref().unwrap_or_default()
-+
+    }
     /// <p>The cron or rate schedule specified for the association when the association version was created.</p>
     pub fn schedule_expression(&self) -> ::std::option::Option<&str> {
         self.schedule_expression.as_deref()
-+
+    }
     /// <p>The location in Amazon S3 specified for the association when the association version was created.</p>
     pub fn output_location(&self) -> ::std::option::Option<&crate::types::InstanceAssociationOutputLocation> {
         self.output_location.as_ref()
-+
+    }
     /// <p>The name specified for the association version when the association version was created.</p>
     pub fn association_name(&self) -> ::std::option::Option<&str> {
         self.association_name.as_deref()
-+
+    }
     /// <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>
     /// <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>
     pub fn max_errors(&self) -> ::std::option::Option<&str> {
         self.max_errors.as_deref()
-+
+    }
     /// <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>
     /// <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>
     pub fn max_concurrency(&self) -> ::std::option::Option<&str> {
         self.max_concurrency.as_deref()
-+
+    }
     /// <p>The severity level that is assigned to the association.</p>
     pub fn compliance_severity(&self) -> ::std::option::Option<&crate::types::AssociationComplianceSeverity> {
         self.compliance_severity.as_ref()
-+
+    }
     /// <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>
     /// <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>
     /// <p>By default, all associations use <code>AUTO</code> mode.</p>
     pub fn sync_compliance(&self) -> ::std::option::Option<&crate::types::AssociationSyncCompliance> {
         self.sync_compliance.as_ref()
-+
+    }
     /// <p>By default, when you create new associations, the system runs it immediately after it is created and then according to the schedule you specified. Specify this option if you don't want an association to run immediately after you create it. This parameter isn't supported for rate expressions.</p>
     pub fn apply_only_at_cron_interval(&self) -> bool {
         self.apply_only_at_cron_interval
-+
+    }
     /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations for this version 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>
     ///
     /// 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()`.
     pub fn calendar_names(&self) -> &[::std::string::String] {
         self.calendar_names.as_deref().unwrap_or_default()
-+
+    }
     /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts where you wanted to run the association when this association version was created.</p>
     ///
     /// 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()`.
     pub fn target_locations(&self) -> &[crate::types::TargetLocation] {
         self.target_locations.as_deref().unwrap_or_default()
-+
+    }
     /// <p>Number of days to wait after the scheduled day to run an association.</p>
     pub fn schedule_offset(&self) -> ::std::option::Option<i32> {
         self.schedule_offset
-+
+    }
     /// <p>The number of hours that an association can run on specified targets. After the resulting cutoff time passes, associations that are currently running are cancelled, and no pending executions are started on remaining targets.</p>
     pub fn duration(&self) -> ::std::option::Option<i32> {
         self.duration
-+
+    }
     /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
     ///
     /// 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()`.
     pub fn target_maps(&self) -> &[::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>] {
         self.target_maps.as_deref().unwrap_or_default()
-+
+    }
     /// <p>A role used by association to take actions on your behalf. State Manager will assume this role and call required APIs when dispatching configurations to nodes. If not specified, <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/using-service-linked-roles.html"> service-linked role for Systems Manager</a> will be used by default.</p>
     pub fn association_dispatch_assume_role(&self) -> ::std::option::Option<&str> {
         self.association_dispatch_assume_role.as_deref()
-+
+    }
-+
+}
 impl ::std::fmt::Debug for AssociationVersionInfo {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("AssociationVersionInfo");
         formatter.field("association_id", &self.association_id);
         formatter.field("association_version", &self.association_version);
         formatter.field("created_date", &self.created_date);
         formatter.field("name", &self.name);
         formatter.field("document_version", &self.document_version);
         formatter.field("parameters", &"*** Sensitive Data Redacted ***");
         formatter.field("targets", &self.targets);
         formatter.field("schedule_expression", &self.schedule_expression);
         formatter.field("output_location", &self.output_location);
         formatter.field("association_name", &self.association_name);
         formatter.field("max_errors", &self.max_errors);
         formatter.field("max_concurrency", &self.max_concurrency);
         formatter.field("compliance_severity", &self.compliance_severity);
         formatter.field("sync_compliance", &self.sync_compliance);
         formatter.field("apply_only_at_cron_interval", &self.apply_only_at_cron_interval);
         formatter.field("calendar_names", &self.calendar_names);
         formatter.field("target_locations", &self.target_locations);
         formatter.field("schedule_offset", &self.schedule_offset);
         formatter.field("duration", &self.duration);
         formatter.field("target_maps", &self.target_maps);
         formatter.field("association_dispatch_assume_role", &self.association_dispatch_assume_role);
         formatter.finish()
-+
+    }
-+
+}
 static ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$AssociationId",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "AssociationId",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_VERSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$AssociationVersion",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "AssociationVersion",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_CREATED_DATE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$CreatedDate",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "CreatedDate",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$Name",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "Name",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_DOCUMENT_VERSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$DocumentVersion",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "DocumentVersion",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#ParameterValueList$member", "com.amazonaws.ssm", "ParameterValueList"),
     ::aws_smithy_schema::ShapeType::String,
     "member",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Parameters$key", "com.amazonaws.ssm", "Parameters"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Parameters$value", "com.amazonaws.ssm", "Parameters"),
     ::aws_smithy_schema::ShapeType::List,
     "value",
 ,
-+
+)
 .with_list_member(&ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_VALUE_MEMBER);
 static ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$Parameters",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "Parameters",
 ,
-+
+)
 .with_map_members(
     &ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_KEY,
     &ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_VALUE,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGETS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Targets$member", "com.amazonaws.ssm", "Targets"),
     ::aws_smithy_schema::ShapeType::Structure,
     "member",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGETS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$Targets",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "Targets",
 ,
-+
+)
 .with_list_member(&ASSOCIATIONVERSIONINFO_MEMBER_TARGETS_MEMBER);
 static ASSOCIATIONVERSIONINFO_MEMBER_SCHEDULE_EXPRESSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$ScheduleExpression",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ScheduleExpression",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_OUTPUT_LOCATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$OutputLocation",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "OutputLocation",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$AssociationName",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "AssociationName",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_MAX_ERRORS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$MaxErrors",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "MaxErrors",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_MAX_CONCURRENCY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$MaxConcurrency",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "MaxConcurrency",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_COMPLIANCE_SEVERITY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$ComplianceSeverity",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ComplianceSeverity",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_SYNC_COMPLIANCE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$SyncCompliance",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "SyncCompliance",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_APPLY_ONLY_AT_CRON_INTERVAL: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$ApplyOnlyAtCronInterval",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "ApplyOnlyAtCronInterval",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_CALENDAR_NAMES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#CalendarNameOrARNList$member",
         "com.amazonaws.ssm",
         "CalendarNameOrARNList",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "member",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_CALENDAR_NAMES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$CalendarNames",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "CalendarNames",
 ,
-+
+)
 .with_list_member(&ASSOCIATIONVERSIONINFO_MEMBER_CALENDAR_NAMES_MEMBER);
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGET_LOCATIONS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetLocations$member", "com.amazonaws.ssm", "TargetLocations"),
     ::aws_smithy_schema::ShapeType::Structure,
     "member",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGET_LOCATIONS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$TargetLocations",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "TargetLocations",
 ,
-+
+)
 .with_list_member(&ASSOCIATIONVERSIONINFO_MEMBER_TARGET_LOCATIONS_MEMBER);
 static ASSOCIATIONVERSIONINFO_MEMBER_SCHEDULE_OFFSET: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$ScheduleOffset",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "ScheduleOffset",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_DURATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$Duration",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "Duration",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMapValueList$member", "com.amazonaws.ssm", "TargetMapValueList"),
     ::aws_smithy_schema::ShapeType::String,
     "member",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$key", "com.amazonaws.ssm", "TargetMap"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
 ,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMap$value", "com.amazonaws.ssm", "TargetMap"),
     ::aws_smithy_schema::ShapeType::List,
     "value",
 ,
-+
+)
 .with_list_member(&ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_VALUE_MEMBER);
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TargetMaps$member", "com.amazonaws.ssm", "TargetMaps"),
     ::aws_smithy_schema::ShapeType::Map,
     "member",
 ,
-+
+)
 .with_map_members(
     &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_KEY,
     &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_VALUE,
 );
 static ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$TargetMaps",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "TargetMaps",
 ,
-+
+)
 .with_list_member(&ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER);
 static ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_DISPATCH_ASSUME_ROLE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#AssociationVersionInfo$AssociationDispatchAssumeRole",
         "com.amazonaws.ssm",
         "AssociationVersionInfo",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "AssociationDispatchAssumeRole",
 ,
 );
 static ASSOCIATIONVERSIONINFO_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationVersionInfo", "com.amazonaws.ssm", "AssociationVersionInfo"),
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_ID,
         &ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_VERSION,
         &ASSOCIATIONVERSIONINFO_MEMBER_CREATED_DATE,
         &ASSOCIATIONVERSIONINFO_MEMBER_NAME,
         &ASSOCIATIONVERSIONINFO_MEMBER_DOCUMENT_VERSION,
         &ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS,
         &ASSOCIATIONVERSIONINFO_MEMBER_TARGETS,
         &ASSOCIATIONVERSIONINFO_MEMBER_SCHEDULE_EXPRESSION,
         &ASSOCIATIONVERSIONINFO_MEMBER_OUTPUT_LOCATION,
         &ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_NAME,
         &ASSOCIATIONVERSIONINFO_MEMBER_MAX_ERRORS,
         &ASSOCIATIONVERSIONINFO_MEMBER_MAX_CONCURRENCY,
         &ASSOCIATIONVERSIONINFO_MEMBER_COMPLIANCE_SEVERITY,
         &ASSOCIATIONVERSIONINFO_MEMBER_SYNC_COMPLIANCE,
         &ASSOCIATIONVERSIONINFO_MEMBER_APPLY_ONLY_AT_CRON_INTERVAL,
         &ASSOCIATIONVERSIONINFO_MEMBER_CALENDAR_NAMES,
         &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_LOCATIONS,
         &ASSOCIATIONVERSIONINFO_MEMBER_SCHEDULE_OFFSET,
         &ASSOCIATIONVERSIONINFO_MEMBER_DURATION,
         &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS,
         &ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_DISPATCH_ASSUME_ROLE,
     ],
 );
 impl AssociationVersionInfo {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &ASSOCIATIONVERSIONINFO_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for AssociationVersionInfo {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.association_id {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_ID, val)?;
-+
+        }
         if let Some(ref val) = self.association_version {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_VERSION, val)?;
-+
+        }
         if let Some(ref val) = self.created_date {
             ser.write_timestamp(&ASSOCIATIONVERSIONINFO_MEMBER_CREATED_DATE, val)?;
-+
+        }
         if let Some(ref val) = self.name {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_NAME, val)?;
-+
+        }
         if let Some(ref val) = self.document_version {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_DOCUMENT_VERSION, val)?;
-+
+        }
         if let Some(ref val) = self.parameters {
             ser.write_map(
                 &ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
-+
                         ser.write_list(
                             &ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_VALUE,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in value {
                                     ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.targets {
             ser.write_list(
                 &ASSOCIATIONVERSIONINFO_MEMBER_TARGETS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Target::SCHEMA, item)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.schedule_expression {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_SCHEDULE_EXPRESSION, val)?;
-+
+        }
         if let Some(ref val) = self.output_location {
             ser.write_struct(&ASSOCIATIONVERSIONINFO_MEMBER_OUTPUT_LOCATION, val)?;
-+
+        }
         if let Some(ref val) = self.association_name {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_NAME, val)?;
-+
+        }
         if let Some(ref val) = self.max_errors {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_MAX_ERRORS, val)?;
-+
+        }
         if let Some(ref val) = self.max_concurrency {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_MAX_CONCURRENCY, val)?;
-+
+        }
         if let Some(ref val) = self.compliance_severity {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_COMPLIANCE_SEVERITY, val.as_str())?;
-+
+        }
         if let Some(ref val) = self.sync_compliance {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_SYNC_COMPLIANCE, val.as_str())?;
-+
+        }
-+
+        {
             let val = &self.apply_only_at_cron_interval;
             ser.write_boolean(&ASSOCIATIONVERSIONINFO_MEMBER_APPLY_ONLY_AT_CRON_INTERVAL, *val)?;
-+
+        }
         if let Some(ref val) = self.calendar_names {
             ser.write_list(
                 &ASSOCIATIONVERSIONINFO_MEMBER_CALENDAR_NAMES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.target_locations {
             ser.write_list(
                 &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_LOCATIONS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TargetLocation::SCHEMA, item)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.schedule_offset {
             ser.write_integer(&ASSOCIATIONVERSIONINFO_MEMBER_SCHEDULE_OFFSET, *val)?;
-+
+        }
         if let Some(ref val) = self.duration {
             ser.write_integer(&ASSOCIATIONVERSIONINFO_MEMBER_DURATION, *val)?;
-+
+        }
         if let Some(ref val) = self.target_maps {
             ser.write_list(
                 &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_map(
                             &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for (key, value) in item {
                                     ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
-+
                                     ser.write_list(
                                         &ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_VALUE,
                                         &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                             for item in value {
                                                 ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-+
+                                            }
                                             Ok(())
                                         },
                                     )?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.association_dispatch_assume_role {
             ser.write_string(&ASSOCIATIONVERSIONINFO_MEMBER_ASSOCIATION_DISPATCH_ASSUME_ROLE, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl AssociationVersionInfo {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&ASSOCIATIONVERSIONINFO_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.association_id = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(1) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.association_version = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(2) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.created_date = Some(deser.read_timestamp(member)?);
-+
+                    }
-+
+                }
                 Some(3) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.name = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(4) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.document_version = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(5) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.parameters = Some({
                             let mut container = std::collections::HashMap::new();
                             deser.read_map(member, &mut |key, deser| {
                                 container.insert(key, {
                                     let mut list = Vec::new();
                                     deser.read_list(&ASSOCIATIONVERSIONINFO_MEMBER_PARAMETERS_VALUE, &mut |deser| {
                                         list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
                                         Ok(())
                                     })?;
                                     list
                                 });
                                 Ok(())
                             })?;
                             container
                         });
-+
+                    }
-+
+                }
                 Some(6) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.targets = Some({
                             let mut container = Vec::new();
                             deser.read_list(member, &mut |deser| {
                                 container.push(crate::types::Target::deserialize(deser)?);
                                 Ok(())
                             })?;
                             container
                         });
-+
+                    }
-+
+                }
                 Some(7) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.schedule_expression = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(8) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.output_location = Some(crate::types::InstanceAssociationOutputLocation::deserialize(deser)?);
-+
+                    }
-+
+                }
                 Some(9) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.association_name = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(10) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.max_errors = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(11) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.max_concurrency = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(12) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.compliance_severity = Some(crate::types::AssociationComplianceSeverity::from(deser.read_string(member)?.as_str()));
-+
+                    }
-+
+                }
                 Some(13) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.sync_compliance = Some(crate::types::AssociationSyncCompliance::from(deser.read_string(member)?.as_str()));
-+
+                    }
-+
+                }
                 Some(14) => {
                     builder.apply_only_at_cron_interval = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(15) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.calendar_names = Some(deser.read_string_list(member)?);
-+
+                    }
-+
+                }
                 Some(16) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.target_locations = Some({
                             let mut container = Vec::new();
                             deser.read_list(member, &mut |deser| {
                                 container.push(crate::types::TargetLocation::deserialize(deser)?);
                                 Ok(())
                             })?;
                             container
                         });
-+
+                    }
-+
+                }
                 Some(17) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.schedule_offset = Some(deser.read_integer(member)?);
-+
+                    }
-+
+                }
                 Some(18) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.duration = Some(deser.read_integer(member)?);
-+
+                    }
-+
+                }
                 Some(19) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.target_maps = Some({
                             let mut container = Vec::new();
                             deser.read_list(member, &mut |deser| {
                                 container.push({
                                     let mut map = ::std::collections::HashMap::new();
                                     deser.read_map(&ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER, &mut |key, deser| {
                                         let value = {
                                             let mut list = Vec::new();
                                             deser.read_list(&ASSOCIATIONVERSIONINFO_MEMBER_TARGET_MAPS_MEMBER_VALUE, &mut |deser| {
                                                 list.push(deser.read_string(&::aws_smithy_schema::prelude::STRING)?);
                                                 Ok(())
                                             })?;
                                             list
                                         };
                                         map.insert(key, value);
                                         Ok(())
                                     })?;
                                     map
                                 });
                                 Ok(())
                             })?;
                             container
                         });
-+
+                    }
-+
+                }
                 Some(20) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.association_dispatch_assume_role = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl AssociationVersionInfo {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl AssociationVersionInfo {
     /// Creates a new builder-style object to manufacture [`AssociationVersionInfo`](crate::types::AssociationVersionInfo).
     pub fn builder() -> crate::types::builders::AssociationVersionInfoBuilder {
         crate::types::builders::AssociationVersionInfoBuilder::default()
-+
+    }
-+
+}
-+
 /// A builder for [`AssociationVersionInfo`](crate::types::AssociationVersionInfo).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct AssociationVersionInfoBuilder {
     pub(crate) association_id: ::std::option::Option<::std::string::String>,
     pub(crate) association_version: ::std::option::Option<::std::string::String>,
     pub(crate) created_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) document_version: ::std::option::Option<::std::string::String>,
     pub(crate) parameters: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
     pub(crate) targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
     pub(crate) schedule_expression: ::std::option::Option<::std::string::String>,
     pub(crate) output_location: ::std::option::Option<crate::types::InstanceAssociationOutputLocation>,
     pub(crate) association_name: ::std::option::Option<::std::string::String>,
     pub(crate) max_errors: ::std::option::Option<::std::string::String>,
     pub(crate) max_concurrency: ::std::option::Option<::std::string::String>,
     pub(crate) compliance_severity: ::std::option::Option<crate::types::AssociationComplianceSeverity>,
     pub(crate) sync_compliance: ::std::option::Option<crate::types::AssociationSyncCompliance>,
     pub(crate) apply_only_at_cron_interval: ::std::option::Option<bool>,
     pub(crate) calendar_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) target_locations: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>,
     pub(crate) schedule_offset: ::std::option::Option<i32>,
     pub(crate) duration: ::std::option::Option<i32>,
     pub(crate) target_maps:
         ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
     pub(crate) association_dispatch_assume_role: ::std::option::Option<::std::string::String>,
-+
+}
 impl AssociationVersionInfoBuilder {
     /// <p>The ID created by the system when the association was created.</p>
     pub fn association_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.association_id = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The ID created by the system when the association was created.</p>
     pub fn set_association_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.association_id = input;
         self
-+
+    }
     /// <p>The ID created by the system when the association was created.</p>
     pub fn get_association_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.association_id
-+
+    }
     /// <p>The association version.</p>
     pub fn association_version(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.association_version = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The association version.</p>
     pub fn set_association_version(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.association_version = input;
         self
-+
+    }
     /// <p>The association version.</p>
     pub fn get_association_version(&self) -> &::std::option::Option<::std::string::String> {
         &self.association_version
-+
+    }
     /// <p>The date the association version was created.</p>
     pub fn created_date(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.created_date = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The date the association version was created.</p>
     pub fn set_created_date(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.created_date = input;
         self
-+
+    }
     /// <p>The date the association version was created.</p>
     pub fn get_created_date(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         &self.created_date
-+
+    }
     /// <p>The name specified when the association was created.</p>
     pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.name = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The name specified when the association was created.</p>
     pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.name = input;
         self
-+
+    }
     /// <p>The name specified when the association was created.</p>
     pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.name
-+
+    }
     /// <p>The version of an Amazon Web Services Systems Manager document (SSM document) used when the association version was created.</p>
     pub fn document_version(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.document_version = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The version of an Amazon Web Services Systems Manager document (SSM document) used when the association version was created.</p>
     pub fn set_document_version(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.document_version = input;
         self
-+
+    }
     /// <p>The version of an Amazon Web Services Systems Manager document (SSM document) used when the association version was created.</p>
     pub fn get_document_version(&self) -> &::std::option::Option<::std::string::String> {
         &self.document_version
-+
+    }
     /// Adds a key-value pair to `parameters`.
     ///
     /// To override the contents of this collection use [`set_parameters`](Self::set_parameters).
     ///
     /// <p>Parameters specified when the association version was created.</p>
     pub fn parameters(mut self, k: impl ::std::convert::Into<::std::string::String>, v: ::std::vec::Vec<::std::string::String>) -> Self {
         let mut hash_map = self.parameters.unwrap_or_default();
         hash_map.insert(k.into(), v);
         self.parameters = ::std::option::Option::Some(hash_map);
         self
-+
+    }
     /// <p>Parameters specified when the association version was created.</p>
     pub fn set_parameters(
         mut self,
         input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>,
     ) -> Self {
         self.parameters = input;
         self
-+
+    }
     /// <p>Parameters specified when the association version was created.</p>
     pub fn get_parameters(
         &self,
     ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>> {
         &self.parameters
-+
+    }
     /// Appends an item to `targets`.
     ///
     /// To override the contents of this collection use [`set_targets`](Self::set_targets).
     ///
     /// <p>The targets specified for the association when the association version was created.</p>
     pub fn targets(mut self, input: crate::types::Target) -> Self {
         let mut v = self.targets.unwrap_or_default();
         v.push(input);
         self.targets = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>The targets specified for the association when the association version was created.</p>
     pub fn set_targets(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Target>>) -> Self {
         self.targets = input;
         self
-+
+    }
     /// <p>The targets specified for the association when the association version was created.</p>
     pub fn get_targets(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Target>> {
         &self.targets
-+
+    }
     /// <p>The cron or rate schedule specified for the association when the association version was created.</p>
     pub fn schedule_expression(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.schedule_expression = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The cron or rate schedule specified for the association when the association version was created.</p>
     pub fn set_schedule_expression(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.schedule_expression = input;
         self
-+
+    }
     /// <p>The cron or rate schedule specified for the association when the association version was created.</p>
     pub fn get_schedule_expression(&self) -> &::std::option::Option<::std::string::String> {
         &self.schedule_expression
-+
+    }
     /// <p>The location in Amazon S3 specified for the association when the association version was created.</p>
     pub fn output_location(mut self, input: crate::types::InstanceAssociationOutputLocation) -> Self {
         self.output_location = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The location in Amazon S3 specified for the association when the association version was created.</p>
     pub fn set_output_location(mut self, input: ::std::option::Option<crate::types::InstanceAssociationOutputLocation>) -> Self {
         self.output_location = input;
         self
-+
+    }
     /// <p>The location in Amazon S3 specified for the association when the association version was created.</p>
     pub fn get_output_location(&self) -> &::std::option::Option<crate::types::InstanceAssociationOutputLocation> {
         &self.output_location
-+
+    }
     /// <p>The name specified for the association version when the association version was created.</p>
     pub fn association_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.association_name = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The name specified for the association version when the association version was created.</p>
     pub fn set_association_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.association_name = input;
         self
-+
+    }
     /// <p>The name specified for the association version when the association version was created.</p>
     pub fn get_association_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.association_name
-+
+    }
     /// <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>
     /// <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>
     pub fn max_errors(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.max_errors = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <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>
     /// <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>
     pub fn set_max_errors(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.max_errors = input;
         self
-+
+    }
     /// <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>
     /// <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>
     pub fn get_max_errors(&self) -> &::std::option::Option<::std::string::String> {
         &self.max_errors
-+
+    }
     /// <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>
     /// <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>
     pub fn max_concurrency(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.max_concurrency = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <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>
     /// <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>
     pub fn set_max_concurrency(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.max_concurrency = input;
         self
-+
+    }
     /// <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>
     /// <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>
     pub fn get_max_concurrency(&self) -> &::std::option::Option<::std::string::String> {
         &self.max_concurrency
-+
+    }
     /// <p>The severity level that is assigned to the association.</p>
     pub fn compliance_severity(mut self, input: crate::types::AssociationComplianceSeverity) -> Self {
         self.compliance_severity = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The severity level that is assigned to the association.</p>
     pub fn set_compliance_severity(mut self, input: ::std::option::Option<crate::types::AssociationComplianceSeverity>) -> Self {
         self.compliance_severity = input;
         self
-+
+    }
     /// <p>The severity level that is assigned to the association.</p>
     pub fn get_compliance_severity(&self) -> &::std::option::Option<crate::types::AssociationComplianceSeverity> {
         &self.compliance_severity
-+
+    }
     /// <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>
     /// <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>
     /// <p>By default, all associations use <code>AUTO</code> mode.</p>
     pub fn sync_compliance(mut self, input: crate::types::AssociationSyncCompliance) -> Self {
         self.sync_compliance = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <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>
     /// <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>
     /// <p>By default, all associations use <code>AUTO</code> mode.</p>
     pub fn set_sync_compliance(mut self, input: ::std::option::Option<crate::types::AssociationSyncCompliance>) -> Self {
         self.sync_compliance = input;
         self
-+
+    }
     /// <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>
     /// <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>
     /// <p>By default, all associations use <code>AUTO</code> mode.</p>
     pub fn get_sync_compliance(&self) -> &::std::option::Option<crate::types::AssociationSyncCompliance> {
         &self.sync_compliance
-+
+    }
     /// <p>By default, when you create new associations, the system runs it immediately after it is created and then according to the schedule you specified. Specify this option if you don't want an association to run immediately after you create it. This parameter isn't supported for rate expressions.</p>
     pub fn apply_only_at_cron_interval(mut self, input: bool) -> Self {
         self.apply_only_at_cron_interval = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>By default, when you create new associations, the system runs it immediately after it is created and then according to the schedule you specified. Specify this option if you don't want an association to run immediately after you create it. This parameter isn't supported for rate expressions.</p>
     pub fn set_apply_only_at_cron_interval(mut self, input: ::std::option::Option<bool>) -> Self {
         self.apply_only_at_cron_interval = input;
         self
-+
+    }
     /// <p>By default, when you create new associations, the system runs it immediately after it is created and then according to the schedule you specified. Specify this option if you don't want an association to run immediately after you create it. This parameter isn't supported for rate expressions.</p>
     pub fn get_apply_only_at_cron_interval(&self) -> &::std::option::Option<bool> {
         &self.apply_only_at_cron_interval
-+
+    }
     /// Appends an item to `calendar_names`.
     ///
     /// To override the contents of this collection use [`set_calendar_names`](Self::set_calendar_names).
     ///
     /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations for this version 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>
     pub fn calendar_names(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut v = self.calendar_names.unwrap_or_default();
         v.push(input.into());
         self.calendar_names = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations for this version 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>
     pub fn set_calendar_names(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         self.calendar_names = input;
         self
-+
+    }
     /// <p>The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations for this version 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>
     pub fn get_calendar_names(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         &self.calendar_names
-+
+    }
     /// Appends an item to `target_locations`.
     ///
     /// To override the contents of this collection use [`set_target_locations`](Self::set_target_locations).
     ///
     /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts where you wanted to run the association when this association version was created.</p>
     pub fn target_locations(mut self, input: crate::types::TargetLocation) -> Self {
         let mut v = self.target_locations.unwrap_or_default();
         v.push(input);
         self.target_locations = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts where you wanted to run the association when this association version was created.</p>
     pub fn set_target_locations(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>>) -> Self {
         self.target_locations = input;
         self
-+
+    }
     /// <p>The combination of Amazon Web Services Regions and Amazon Web Services accounts where you wanted to run the association when this association version was created.</p>
     pub fn get_target_locations(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::TargetLocation>> {
         &self.target_locations
-+
+    }
     /// <p>Number of days to wait after the scheduled day to run an association.</p>
     pub fn schedule_offset(mut self, input: i32) -> Self {
         self.schedule_offset = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>Number of days to wait after the scheduled day to run an association.</p>
     pub fn set_schedule_offset(mut self, input: ::std::option::Option<i32>) -> Self {
         self.schedule_offset = input;
         self
-+
+    }
     /// <p>Number of days to wait after the scheduled day to run an association.</p>
     pub fn get_schedule_offset(&self) -> &::std::option::Option<i32> {
         &self.schedule_offset
-+
+    }
     /// <p>The number of hours that an association can run on specified targets. After the resulting cutoff time passes, associations that are currently running are cancelled, and no pending executions are started on remaining targets.</p>
     pub fn duration(mut self, input: i32) -> Self {
         self.duration = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The number of hours that an association can run on specified targets. After the resulting cutoff time passes, associations that are currently running are cancelled, and no pending executions are started on remaining targets.</p>
     pub fn set_duration(mut self, input: ::std::option::Option<i32>) -> Self {
         self.duration = input;
         self
-+
+    }
     /// <p>The number of hours that an association can run on specified targets. After the resulting cutoff time passes, associations that are currently running are cancelled, and no pending executions are started on remaining targets.</p>
     pub fn get_duration(&self) -> &::std::option::Option<i32> {
         &self.duration
-+
+    }
     /// Appends an item to `target_maps`.
     ///
     /// To override the contents of this collection use [`set_target_maps`](Self::set_target_maps).
     ///
     /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
     pub fn target_maps(mut self, input: ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>) -> Self {
         let mut v = self.target_maps.unwrap_or_default();
         v.push(input);
         self.target_maps = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
     pub fn set_target_maps(
         mut self,
         input: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>>,
     ) -> Self {
         self.target_maps = input;
         self
-+
+    }
     /// <p>A key-value mapping of document parameters to target resources. Both Targets and TargetMaps can't be specified together.</p>
     pub fn get_target_maps(
         &self,
     ) -> &::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>>> {
         &self.target_maps
-+
+    }
     /// <p>A role used by association to take actions on your behalf. State Manager will assume this role and call required APIs when dispatching configurations to nodes. If not specified, <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/using-service-linked-roles.html"> service-linked role for Systems Manager</a> will be used by default.</p>
     pub fn association_dispatch_assume_role(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.association_dispatch_assume_role = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>A role used by association to take actions on your behalf. State Manager will assume this role and call required APIs when dispatching configurations to nodes. If not specified, <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/using-service-linked-roles.html"> service-linked role for Systems Manager</a> will be used by default.</p>
     pub fn set_association_dispatch_assume_role(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.association_dispatch_assume_role = input;
         self
-+
+    }
     /// <p>A role used by association to take actions on your behalf. State Manager will assume this role and call required APIs when dispatching configurations to nodes. If not specified, <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/using-service-linked-roles.html"> service-linked role for Systems Manager</a> will be used by default.</p>
     pub fn get_association_dispatch_assume_role(&self) -> &::std::option::Option<::std::string::String> {
         &self.association_dispatch_assume_role
-+
+    }
     /// Consumes the builder and constructs a [`AssociationVersionInfo`](crate::types::AssociationVersionInfo).
     pub fn build(self) -> crate::types::AssociationVersionInfo {
         crate::types::AssociationVersionInfo {
             association_id: self.association_id,
             association_version: self.association_version,
             created_date: self.created_date,
             name: self.name,
             document_version: self.document_version,
             parameters: self.parameters,
             targets: self.targets,
             schedule_expression: self.schedule_expression,
             output_location: self.output_location,
             association_name: self.association_name,
             max_errors: self.max_errors,
             max_concurrency: self.max_concurrency,
             compliance_severity: self.compliance_severity,
             sync_compliance: self.sync_compliance,
             apply_only_at_cron_interval: self.apply_only_at_cron_interval.unwrap_or_default(),
             calendar_names: self.calendar_names,
             target_locations: self.target_locations,
             schedule_offset: self.schedule_offset,
             duration: self.duration,
             target_maps: self.target_maps,
             association_dispatch_assume_role: self.association_dispatch_assume_role,
-+
+        }
-+
+    }
-+
+}
 impl ::std::fmt::Debug for AssociationVersionInfoBuilder {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("AssociationVersionInfoBuilder");
         formatter.field("association_id", &self.association_id);
         formatter.field("association_version", &self.association_version);
         formatter.field("created_date", &self.created_date);
         formatter.field("name", &self.name);
         formatter.field("document_version", &self.document_version);
         formatter.field("parameters", &"*** Sensitive Data Redacted ***");
         formatter.field("targets", &self.targets);
         formatter.field("schedule_expression", &self.schedule_expression);
         formatter.field("output_location", &self.output_location);
         formatter.field("association_name", &self.association_name);
         formatter.field("max_errors", &self.max_errors);
         formatter.field("max_concurrency", &self.max_concurrency);
         formatter.field("compliance_severity", &self.compliance_severity);
         formatter.field("sync_compliance", &self.sync_compliance);
         formatter.field("apply_only_at_cron_interval", &self.apply_only_at_cron_interval);
         formatter.field("calendar_names", &self.calendar_names);
         formatter.field("target_locations", &self.target_locations);
         formatter.field("schedule_offset", &self.schedule_offset);
         formatter.field("duration", &self.duration);
         formatter.field("target_maps", &self.target_maps);
         formatter.field("association_dispatch_assume_role", &self.association_dispatch_assume_role);
         formatter.finish()
-+
+    }
-+
+}

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285