AWS SDK

AWS SDK

rev. 97ba95e6039d206ffea5b866ddc214d34f7f88c3 (ignoring whitespace)

Files changed:

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

@@ -0,1 +0,167 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// <p>This data type is deprecated. Instead, use <code>DocumentKeyValuesFilter</code>.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DocumentFilter {
     /// <p>The name of the filter.</p>
     pub key: crate::types::DocumentFilterKey,
     /// <p>The value of the filter.</p>
     pub value: ::std::string::String,
-+
+}
 impl DocumentFilter {
     /// <p>The name of the filter.</p>
     pub fn key(&self) -> &crate::types::DocumentFilterKey {
         &self.key
-+
+    }
     /// <p>The value of the filter.</p>
     pub fn value(&self) -> &str {
         use std::ops::Deref;
         self.value.deref()
-+
+    }
-+
+}
 static DOCUMENTFILTER_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentFilter$key", "com.amazonaws.ssm", "DocumentFilter"),
     ::aws_smithy_schema::ShapeType::String,
     "key",
 ,
 );
 static DOCUMENTFILTER_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentFilter$value", "com.amazonaws.ssm", "DocumentFilter"),
     ::aws_smithy_schema::ShapeType::String,
     "value",
 ,
 );
 static DOCUMENTFILTER_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentFilter", "com.amazonaws.ssm", "DocumentFilter"),
     ::aws_smithy_schema::ShapeType::Structure,
     &[&DOCUMENTFILTER_MEMBER_KEY, &DOCUMENTFILTER_MEMBER_VALUE],
 );
 impl DocumentFilter {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &DOCUMENTFILTER_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DocumentFilter {
     #[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.key;
             ser.write_string(&DOCUMENTFILTER_MEMBER_KEY, val.as_str())?;
-+
+        }
-+
+        {
             let val = &self.value;
             ser.write_string(&DOCUMENTFILTER_MEMBER_VALUE, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl DocumentFilter {
     /// 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(&DOCUMENTFILTER_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.key = Some(crate::types::DocumentFilterKey::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(1) => {
                     builder.value = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.value = builder.value.or(Some(String::new()));
         builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
-+
+    }
-+
+}
 impl DocumentFilter {
     /// 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 DocumentFilter {
     /// Creates a new builder-style object to manufacture [`DocumentFilter`](crate::types::DocumentFilter).
     pub fn builder() -> crate::types::builders::DocumentFilterBuilder {
         crate::types::builders::DocumentFilterBuilder::default()
-+
+    }
-+
+}
-+
 /// A builder for [`DocumentFilter`](crate::types::DocumentFilter).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DocumentFilterBuilder {
     pub(crate) key: ::std::option::Option<crate::types::DocumentFilterKey>,
     pub(crate) value: ::std::option::Option<::std::string::String>,
-+
+}
 impl DocumentFilterBuilder {
     /// <p>The name of the filter.</p>
     /// This field is required.
     pub fn key(mut self, input: crate::types::DocumentFilterKey) -> Self {
         self.key = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The name of the filter.</p>
     pub fn set_key(mut self, input: ::std::option::Option<crate::types::DocumentFilterKey>) -> Self {
         self.key = input;
         self
-+
+    }
     /// <p>The name of the filter.</p>
     pub fn get_key(&self) -> &::std::option::Option<crate::types::DocumentFilterKey> {
         &self.key
-+
+    }
     /// <p>The value of the filter.</p>
     /// This field is required.
     pub fn value(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.value = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The value of the filter.</p>
     pub fn set_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.value = input;
         self
-+
+    }
     /// <p>The value of the filter.</p>
     pub fn get_value(&self) -> &::std::option::Option<::std::string::String> {
         &self.value
-+
+    }
     /// Consumes the builder and constructs a [`DocumentFilter`](crate::types::DocumentFilter).
     /// This method will fail if any of the following fields are not set:
     /// - [`key`](crate::types::builders::DocumentFilterBuilder::key)
     /// - [`value`](crate::types::builders::DocumentFilterBuilder::value)
     pub fn build(self) -> ::std::result::Result<crate::types::DocumentFilter, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::types::DocumentFilter {
             key: self.key.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "key",
                     "key was not specified but it is required when building DocumentFilter",
-+
+                )
             })?,
             value: self.value.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "value",
                     "value was not specified but it is required when building DocumentFilter",
-+
+                )
             })?,
         })
-+
+    }
-+
+}

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

@@ -0,1 +0,120 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// When writing a match expression against `DocumentFilterKey`, 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 documentfilterkey = unimplemented!();
 /// match documentfilterkey {
 ///     DocumentFilterKey::DocumentType => { /* ... */ },
 ///     DocumentFilterKey::Name => { /* ... */ },
 ///     DocumentFilterKey::Owner => { /* ... */ },
 ///     DocumentFilterKey::PlatformTypes => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `documentfilterkey` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `DocumentFilterKey::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `DocumentFilterKey::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 `DocumentFilterKey::NewFeature` is defined.
 /// Specifically, when `documentfilterkey` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `DocumentFilterKey::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 DocumentFilterKey {
     #[allow(missing_docs)] // documentation missing in model
     DocumentType,
     #[allow(missing_docs)] // documentation missing in model
     Name,
     #[allow(missing_docs)] // documentation missing in model
     Owner,
     #[allow(missing_docs)] // documentation missing in model
     PlatformTypes,
     /// `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 DocumentFilterKey {
     fn from(s: &str) -> Self {
         match s {
             "DocumentType" => DocumentFilterKey::DocumentType,
             "Name" => DocumentFilterKey::Name,
             "Owner" => DocumentFilterKey::Owner,
             "PlatformTypes" => DocumentFilterKey::PlatformTypes,
             other => DocumentFilterKey::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
-+
+        }
-+
+    }
-+
+}
 impl ::std::str::FromStr for DocumentFilterKey {
     type Err = ::std::convert::Infallible;
-+
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(DocumentFilterKey::from(s))
-+
+    }
-+
+}
 impl DocumentFilterKey {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             DocumentFilterKey::DocumentType => "DocumentType",
             DocumentFilterKey::Name => "Name",
             DocumentFilterKey::Owner => "Owner",
             DocumentFilterKey::PlatformTypes => "PlatformTypes",
             DocumentFilterKey::Unknown(value) => value.as_str(),
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["DocumentType", "Name", "Owner", "PlatformTypes"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for DocumentFilterKey {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl DocumentFilterKey {
     /// 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 DocumentFilterKey {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             DocumentFilterKey::DocumentType => write!(f, "DocumentType"),
             DocumentFilterKey::Name => write!(f, "Name"),
             DocumentFilterKey::Owner => write!(f, "Owner"),
             DocumentFilterKey::PlatformTypes => write!(f, "PlatformTypes"),
             DocumentFilterKey::Unknown(value) => write!(f, "{value}"),
-+
+        }
-+
+    }
-+
+}

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// When writing a match expression against `DocumentFormat`, 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 documentformat = unimplemented!();
 /// match documentformat {
 ///     DocumentFormat::Json => { /* ... */ },
 ///     DocumentFormat::Text => { /* ... */ },
 ///     DocumentFormat::Yaml => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `documentformat` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `DocumentFormat::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `DocumentFormat::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 `DocumentFormat::NewFeature` is defined.
 /// Specifically, when `documentformat` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `DocumentFormat::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 DocumentFormat {
     #[allow(missing_docs)] // documentation missing in model
     Json,
     #[allow(missing_docs)] // documentation missing in model
     Text,
     #[allow(missing_docs)] // documentation missing in model
     Yaml,
     /// `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 DocumentFormat {
     fn from(s: &str) -> Self {
         match s {
             "JSON" => DocumentFormat::Json,
             "TEXT" => DocumentFormat::Text,
             "YAML" => DocumentFormat::Yaml,
             other => DocumentFormat::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
-+
+        }
-+
+    }
-+
+}
 impl ::std::str::FromStr for DocumentFormat {
     type Err = ::std::convert::Infallible;
-+
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(DocumentFormat::from(s))
-+
+    }
-+
+}
 impl DocumentFormat {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             DocumentFormat::Json => "JSON",
             DocumentFormat::Text => "TEXT",
             DocumentFormat::Yaml => "YAML",
             DocumentFormat::Unknown(value) => value.as_str(),
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["JSON", "TEXT", "YAML"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for DocumentFormat {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl DocumentFormat {
     /// 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 DocumentFormat {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             DocumentFormat::Json => write!(f, "JSON"),
             DocumentFormat::Text => write!(f, "TEXT"),
             DocumentFormat::Yaml => write!(f, "YAML"),
             DocumentFormat::Unknown(value) => write!(f, "{value}"),
-+
+        }
-+
+    }
-+
+}

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// When writing a match expression against `DocumentHashType`, 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 documenthashtype = unimplemented!();
 /// match documenthashtype {
 ///     DocumentHashType::Sha1 => { /* ... */ },
 ///     DocumentHashType::Sha256 => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `documenthashtype` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `DocumentHashType::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `DocumentHashType::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 `DocumentHashType::NewFeature` is defined.
 /// Specifically, when `documenthashtype` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `DocumentHashType::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 DocumentHashType {
     #[allow(missing_docs)] // documentation missing in model
     Sha1,
     #[allow(missing_docs)] // documentation missing in model
     Sha256,
     /// `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 DocumentHashType {
     fn from(s: &str) -> Self {
         match s {
             "Sha1" => DocumentHashType::Sha1,
             "Sha256" => DocumentHashType::Sha256,
             other => DocumentHashType::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
-+
+        }
-+
+    }
-+
+}
 impl ::std::str::FromStr for DocumentHashType {
     type Err = ::std::convert::Infallible;
-+
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(DocumentHashType::from(s))
-+
+    }
-+
+}
 impl DocumentHashType {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             DocumentHashType::Sha1 => "Sha1",
             DocumentHashType::Sha256 => "Sha256",
             DocumentHashType::Unknown(value) => value.as_str(),
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["Sha1", "Sha256"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for DocumentHashType {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl DocumentHashType {
     /// 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 DocumentHashType {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             DocumentHashType::Sha1 => write!(f, "Sha1"),
             DocumentHashType::Sha256 => write!(f, "Sha256"),
             DocumentHashType::Unknown(value) => write!(f, "{value}"),
-+
+        }
-+
+    }
-+
+}

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

@@ -0,1 +0,803 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 /// <p>Describes the name of a SSM document.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct DocumentIdentifier {
     /// <p>The name of the SSM document.</p>
     pub name: ::std::option::Option<::std::string::String>,
     /// <p>The date the SSM document was created.</p>
     pub created_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     /// <p>An optional field where you can specify a friendly name for the SSM document. This value can differ for each version of the document. If you want to update this value, see <code>UpdateDocument</code>.</p>
     pub display_name: ::std::option::Option<::std::string::String>,
     /// <p>The Amazon Web Services user that created the document.</p>
     pub owner: ::std::option::Option<::std::string::String>,
     /// <p>An optional field specifying the version of the artifact associated with the document. For example, 12.6. This value is unique across all versions of a document, and can't be changed.</p>
     pub version_name: ::std::option::Option<::std::string::String>,
     /// <p>The operating system platform.</p>
     pub platform_types: ::std::option::Option<::std::vec::Vec<crate::types::PlatformType>>,
     /// <p>The document version.</p>
     pub document_version: ::std::option::Option<::std::string::String>,
     /// <p>The document type.</p>
     pub document_type: ::std::option::Option<crate::types::DocumentType>,
     /// <p>The schema version.</p>
     pub schema_version: ::std::option::Option<::std::string::String>,
     /// <p>The document format, either JSON or YAML.</p>
     pub document_format: ::std::option::Option<crate::types::DocumentFormat>,
     /// <p>The target type which defines the kinds of resources the document can run on. For example, <code>/AWS::EC2::Instance</code>. For a list of valid resource types, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html">Amazon Web Services resource and property types reference</a> in the <i>CloudFormation User Guide</i>.</p>
     pub target_type: ::std::option::Option<::std::string::String>,
     /// <p>The tags, or metadata, that have been applied to the document.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     /// <p>A list of SSM documents required by a document. For example, an <code>ApplicationConfiguration</code> document requires an <code>ApplicationConfigurationSchema</code> document.</p>
     pub requires: ::std::option::Option<::std::vec::Vec<crate::types::DocumentRequires>>,
     /// <p>The current status of a document review.</p>
     pub review_status: ::std::option::Option<crate::types::ReviewStatus>,
     /// <p>The user in your organization who created the document.</p>
     pub author: ::std::option::Option<::std::string::String>,
-+
+}
 impl DocumentIdentifier {
     /// <p>The name of the SSM document.</p>
     pub fn name(&self) -> ::std::option::Option<&str> {
         self.name.as_deref()
-+
+    }
     /// <p>The date the SSM document was created.</p>
     pub fn created_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.created_date.as_ref()
-+
+    }
     /// <p>An optional field where you can specify a friendly name for the SSM document. This value can differ for each version of the document. If you want to update this value, see <code>UpdateDocument</code>.</p>
     pub fn display_name(&self) -> ::std::option::Option<&str> {
         self.display_name.as_deref()
-+
+    }
     /// <p>The Amazon Web Services user that created the document.</p>
     pub fn owner(&self) -> ::std::option::Option<&str> {
         self.owner.as_deref()
-+
+    }
     /// <p>An optional field specifying the version of the artifact associated with the document. For example, 12.6. This value is unique across all versions of a document, and can't be changed.</p>
     pub fn version_name(&self) -> ::std::option::Option<&str> {
         self.version_name.as_deref()
-+
+    }
     /// <p>The operating system platform.</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 `.platform_types.is_none()`.
     pub fn platform_types(&self) -> &[crate::types::PlatformType] {
         self.platform_types.as_deref().unwrap_or_default()
-+
+    }
     /// <p>The document version.</p>
     pub fn document_version(&self) -> ::std::option::Option<&str> {
         self.document_version.as_deref()
-+
+    }
     /// <p>The document type.</p>
     pub fn document_type(&self) -> ::std::option::Option<&crate::types::DocumentType> {
         self.document_type.as_ref()
-+
+    }
     /// <p>The schema version.</p>
     pub fn schema_version(&self) -> ::std::option::Option<&str> {
         self.schema_version.as_deref()
-+
+    }
     /// <p>The document format, either JSON or YAML.</p>
     pub fn document_format(&self) -> ::std::option::Option<&crate::types::DocumentFormat> {
         self.document_format.as_ref()
-+
+    }
     /// <p>The target type which defines the kinds of resources the document can run on. For example, <code>/AWS::EC2::Instance</code>. For a list of valid resource types, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html">Amazon Web Services resource and property types reference</a> in the <i>CloudFormation User Guide</i>.</p>
     pub fn target_type(&self) -> ::std::option::Option<&str> {
         self.target_type.as_deref()
-+
+    }
     /// <p>The tags, or metadata, that have been applied to the document.</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 `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-+
+    }
     /// <p>A list of SSM documents required by a document. For example, an <code>ApplicationConfiguration</code> document requires an <code>ApplicationConfigurationSchema</code> document.</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 `.requires.is_none()`.
     pub fn requires(&self) -> &[crate::types::DocumentRequires] {
         self.requires.as_deref().unwrap_or_default()
-+
+    }
     /// <p>The current status of a document review.</p>
     pub fn review_status(&self) -> ::std::option::Option<&crate::types::ReviewStatus> {
         self.review_status.as_ref()
-+
+    }
     /// <p>The user in your organization who created the document.</p>
     pub fn author(&self) -> ::std::option::Option<&str> {
         self.author.as_deref()
-+
+    }
-+
+}
 static DOCUMENTIDENTIFIER_MEMBER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentIdentifier$Name", "com.amazonaws.ssm", "DocumentIdentifier"),
     ::aws_smithy_schema::ShapeType::String,
     "Name",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_CREATED_DATE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$CreatedDate",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "CreatedDate",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_DISPLAY_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$DisplayName",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "DisplayName",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_OWNER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentIdentifier$Owner", "com.amazonaws.ssm", "DocumentIdentifier"),
     ::aws_smithy_schema::ShapeType::String,
     "Owner",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_VERSION_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$VersionName",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "VersionName",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_PLATFORM_TYPES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#PlatformTypeList$member", "com.amazonaws.ssm", "PlatformTypeList"),
     ::aws_smithy_schema::ShapeType::String,
     "member",
 ,
-+
+)
 .with_xml_name("PlatformType");
 static DOCUMENTIDENTIFIER_MEMBER_PLATFORM_TYPES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$PlatformTypes",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "PlatformTypes",
 ,
-+
+)
 .with_list_member(&DOCUMENTIDENTIFIER_MEMBER_PLATFORM_TYPES_MEMBER);
 static DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_VERSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$DocumentVersion",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "DocumentVersion",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_TYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$DocumentType",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "DocumentType",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_SCHEMA_VERSION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$SchemaVersion",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "SchemaVersion",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_FORMAT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$DocumentFormat",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "DocumentFormat",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_TARGET_TYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$TargetType",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "TargetType",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_TAGS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#TagList$member", "com.amazonaws.ssm", "TagList"),
     ::aws_smithy_schema::ShapeType::Structure,
     "member",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_TAGS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentIdentifier$Tags", "com.amazonaws.ssm", "DocumentIdentifier"),
     ::aws_smithy_schema::ShapeType::List,
     "Tags",
 ,
-+
+)
 .with_list_member(&DOCUMENTIDENTIFIER_MEMBER_TAGS_MEMBER);
 static DOCUMENTIDENTIFIER_MEMBER_REQUIRES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentRequiresList$member",
         "com.amazonaws.ssm",
         "DocumentRequiresList",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "member",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_REQUIRES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentIdentifier$Requires", "com.amazonaws.ssm", "DocumentIdentifier"),
     ::aws_smithy_schema::ShapeType::List,
     "Requires",
 ,
-+
+)
 .with_list_member(&DOCUMENTIDENTIFIER_MEMBER_REQUIRES_MEMBER);
 static DOCUMENTIDENTIFIER_MEMBER_REVIEW_STATUS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts(
         "com.amazonaws.ssm#DocumentIdentifier$ReviewStatus",
         "com.amazonaws.ssm",
         "DocumentIdentifier",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ReviewStatus",
 ,
 );
 static DOCUMENTIDENTIFIER_MEMBER_AUTHOR: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentIdentifier$Author", "com.amazonaws.ssm", "DocumentIdentifier"),
     ::aws_smithy_schema::ShapeType::String,
     "Author",
 ,
 );
 static DOCUMENTIDENTIFIER_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
     ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#DocumentIdentifier", "com.amazonaws.ssm", "DocumentIdentifier"),
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &DOCUMENTIDENTIFIER_MEMBER_NAME,
         &DOCUMENTIDENTIFIER_MEMBER_CREATED_DATE,
         &DOCUMENTIDENTIFIER_MEMBER_DISPLAY_NAME,
         &DOCUMENTIDENTIFIER_MEMBER_OWNER,
         &DOCUMENTIDENTIFIER_MEMBER_VERSION_NAME,
         &DOCUMENTIDENTIFIER_MEMBER_PLATFORM_TYPES,
         &DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_VERSION,
         &DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_TYPE,
         &DOCUMENTIDENTIFIER_MEMBER_SCHEMA_VERSION,
         &DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_FORMAT,
         &DOCUMENTIDENTIFIER_MEMBER_TARGET_TYPE,
         &DOCUMENTIDENTIFIER_MEMBER_TAGS,
         &DOCUMENTIDENTIFIER_MEMBER_REQUIRES,
         &DOCUMENTIDENTIFIER_MEMBER_REVIEW_STATUS,
         &DOCUMENTIDENTIFIER_MEMBER_AUTHOR,
     ],
 );
 impl DocumentIdentifier {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &DOCUMENTIDENTIFIER_SCHEMA;
-+
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for DocumentIdentifier {
     #[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.name {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_NAME, val)?;
-+
+        }
         if let Some(ref val) = self.created_date {
             ser.write_timestamp(&DOCUMENTIDENTIFIER_MEMBER_CREATED_DATE, val)?;
-+
+        }
         if let Some(ref val) = self.display_name {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_DISPLAY_NAME, val)?;
-+
+        }
         if let Some(ref val) = self.owner {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_OWNER, val)?;
-+
+        }
         if let Some(ref val) = self.version_name {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_VERSION_NAME, val)?;
-+
+        }
         if let Some(ref val) = self.platform_types {
             ser.write_list(
                 &DOCUMENTIDENTIFIER_MEMBER_PLATFORM_TYPES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.document_version {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_VERSION, val)?;
-+
+        }
         if let Some(ref val) = self.document_type {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_TYPE, val.as_str())?;
-+
+        }
         if let Some(ref val) = self.schema_version {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_SCHEMA_VERSION, val)?;
-+
+        }
         if let Some(ref val) = self.document_format {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_DOCUMENT_FORMAT, val.as_str())?;
-+
+        }
         if let Some(ref val) = self.target_type {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_TARGET_TYPE, val)?;
-+
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &DOCUMENTIDENTIFIER_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.requires {
             ser.write_list(
                 &DOCUMENTIDENTIFIER_MEMBER_REQUIRES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::DocumentRequires::SCHEMA, item)?;
-+
+                    }
                     Ok(())
                 },
             )?;
-+
+        }
         if let Some(ref val) = self.review_status {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_REVIEW_STATUS, val.as_str())?;
-+
+        }
         if let Some(ref val) = self.author {
             ser.write_string(&DOCUMENTIDENTIFIER_MEMBER_AUTHOR, val)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl DocumentIdentifier {
     /// 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(&DOCUMENTIDENTIFIER_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.name = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(1) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.created_date = Some(deser.read_timestamp(member)?);
-+
+                    }
-+
+                }
                 Some(2) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.display_name = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(3) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.owner = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(4) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.version_name = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(5) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.platform_types = Some({
                             let mut container = Vec::new();
                             deser.read_list(member, &mut |deser| {
                                 container.push(crate::types::PlatformType::from(
                                     deser.read_string(&::aws_smithy_schema::prelude::STRING)?.as_str(),
                                 ));
                                 Ok(())
                             })?;
                             container
                         });
-+
+                    }
-+
+                }
                 Some(6) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.document_version = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(7) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.document_type = Some(crate::types::DocumentType::from(deser.read_string(member)?.as_str()));
-+
+                    }
-+
+                }
                 Some(8) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.schema_version = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(9) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.document_format = Some(crate::types::DocumentFormat::from(deser.read_string(member)?.as_str()));
-+
+                    }
-+
+                }
                 Some(10) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.target_type = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 Some(11) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.tags = Some({
                             let mut container = Vec::new();
                             deser.read_list(member, &mut |deser| {
                                 container.push(crate::types::Tag::deserialize(deser)?);
                                 Ok(())
                             })?;
                             container
                         });
-+
+                    }
-+
+                }
                 Some(12) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.requires = Some({
                             let mut container = Vec::new();
                             deser.read_list(member, &mut |deser| {
                                 container.push(crate::types::DocumentRequires::deserialize(deser)?);
                                 Ok(())
                             })?;
                             container
                         });
-+
+                    }
-+
+                }
                 Some(13) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.review_status = Some(crate::types::ReviewStatus::from(deser.read_string(member)?.as_str()));
-+
+                    }
-+
+                }
                 Some(14) => {
                     if deser.is_null() {
                         deser.read_null()?;
                     } else {
                         builder.author = Some(deser.read_string(member)?);
-+
+                    }
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl DocumentIdentifier {
     /// 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 DocumentIdentifier {
     /// Creates a new builder-style object to manufacture [`DocumentIdentifier`](crate::types::DocumentIdentifier).
     pub fn builder() -> crate::types::builders::DocumentIdentifierBuilder {
         crate::types::builders::DocumentIdentifierBuilder::default()
-+
+    }
-+
+}
-+
 /// A builder for [`DocumentIdentifier`](crate::types::DocumentIdentifier).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct DocumentIdentifierBuilder {
     pub(crate) name: ::std::option::Option<::std::string::String>,
     pub(crate) created_date: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) display_name: ::std::option::Option<::std::string::String>,
     pub(crate) owner: ::std::option::Option<::std::string::String>,
     pub(crate) version_name: ::std::option::Option<::std::string::String>,
     pub(crate) platform_types: ::std::option::Option<::std::vec::Vec<crate::types::PlatformType>>,
     pub(crate) document_version: ::std::option::Option<::std::string::String>,
     pub(crate) document_type: ::std::option::Option<crate::types::DocumentType>,
     pub(crate) schema_version: ::std::option::Option<::std::string::String>,
     pub(crate) document_format: ::std::option::Option<crate::types::DocumentFormat>,
     pub(crate) target_type: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) requires: ::std::option::Option<::std::vec::Vec<crate::types::DocumentRequires>>,
     pub(crate) review_status: ::std::option::Option<crate::types::ReviewStatus>,
     pub(crate) author: ::std::option::Option<::std::string::String>,
-+
+}
 impl DocumentIdentifierBuilder {
     /// <p>The name of the SSM document.</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 of the SSM document.</p>
     pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.name = input;
         self
-+
+    }
     /// <p>The name of the SSM document.</p>
     pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.name
-+
+    }
     /// <p>The date the SSM document 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 SSM document 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 SSM document was created.</p>
     pub fn get_created_date(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         &self.created_date
-+
+    }
     /// <p>An optional field where you can specify a friendly name for the SSM document. This value can differ for each version of the document. If you want to update this value, see <code>UpdateDocument</code>.</p>
     pub fn display_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.display_name = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>An optional field where you can specify a friendly name for the SSM document. This value can differ for each version of the document. If you want to update this value, see <code>UpdateDocument</code>.</p>
     pub fn set_display_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.display_name = input;
         self
-+
+    }
     /// <p>An optional field where you can specify a friendly name for the SSM document. This value can differ for each version of the document. If you want to update this value, see <code>UpdateDocument</code>.</p>
     pub fn get_display_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.display_name
-+
+    }
     /// <p>The Amazon Web Services user that created the document.</p>
     pub fn owner(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.owner = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The Amazon Web Services user that created the document.</p>
     pub fn set_owner(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.owner = input;
         self
-+
+    }
     /// <p>The Amazon Web Services user that created the document.</p>
     pub fn get_owner(&self) -> &::std::option::Option<::std::string::String> {
         &self.owner
-+
+    }
     /// <p>An optional field specifying the version of the artifact associated with the document. For example, 12.6. This value is unique across all versions of a document, and can't be changed.</p>
     pub fn version_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.version_name = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>An optional field specifying the version of the artifact associated with the document. For example, 12.6. This value is unique across all versions of a document, and can't be changed.</p>
     pub fn set_version_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.version_name = input;
         self
-+
+    }
     /// <p>An optional field specifying the version of the artifact associated with the document. For example, 12.6. This value is unique across all versions of a document, and can't be changed.</p>
     pub fn get_version_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.version_name
-+
+    }
     /// Appends an item to `platform_types`.
     ///
     /// To override the contents of this collection use [`set_platform_types`](Self::set_platform_types).
     ///
     /// <p>The operating system platform.</p>
     pub fn platform_types(mut self, input: crate::types::PlatformType) -> Self {
         let mut v = self.platform_types.unwrap_or_default();
         v.push(input);
         self.platform_types = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>The operating system platform.</p>
     pub fn set_platform_types(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::PlatformType>>) -> Self {
         self.platform_types = input;
         self
-+
+    }
     /// <p>The operating system platform.</p>
     pub fn get_platform_types(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::PlatformType>> {
         &self.platform_types
-+
+    }
     /// <p>The document version.</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 document version.</p>
     pub fn set_document_version(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.document_version = input;
         self
-+
+    }
     /// <p>The document version.</p>
     pub fn get_document_version(&self) -> &::std::option::Option<::std::string::String> {
         &self.document_version
-+
+    }
     /// <p>The document type.</p>
     pub fn document_type(mut self, input: crate::types::DocumentType) -> Self {
         self.document_type = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The document type.</p>
     pub fn set_document_type(mut self, input: ::std::option::Option<crate::types::DocumentType>) -> Self {
         self.document_type = input;
         self
-+
+    }
     /// <p>The document type.</p>
     pub fn get_document_type(&self) -> &::std::option::Option<crate::types::DocumentType> {
         &self.document_type
-+
+    }
     /// <p>The schema version.</p>
     pub fn schema_version(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.schema_version = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The schema version.</p>
     pub fn set_schema_version(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.schema_version = input;
         self
-+
+    }
     /// <p>The schema version.</p>
     pub fn get_schema_version(&self) -> &::std::option::Option<::std::string::String> {
         &self.schema_version
-+
+    }
     /// <p>The document format, either JSON or YAML.</p>
     pub fn document_format(mut self, input: crate::types::DocumentFormat) -> Self {
         self.document_format = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The document format, either JSON or YAML.</p>
     pub fn set_document_format(mut self, input: ::std::option::Option<crate::types::DocumentFormat>) -> Self {
         self.document_format = input;
         self
-+
+    }
     /// <p>The document format, either JSON or YAML.</p>
     pub fn get_document_format(&self) -> &::std::option::Option<crate::types::DocumentFormat> {
         &self.document_format
-+
+    }
     /// <p>The target type which defines the kinds of resources the document can run on. For example, <code>/AWS::EC2::Instance</code>. For a list of valid resource types, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html">Amazon Web Services resource and property types reference</a> in the <i>CloudFormation User Guide</i>.</p>
     pub fn target_type(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.target_type = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The target type which defines the kinds of resources the document can run on. For example, <code>/AWS::EC2::Instance</code>. For a list of valid resource types, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html">Amazon Web Services resource and property types reference</a> in the <i>CloudFormation User Guide</i>.</p>
     pub fn set_target_type(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.target_type = input;
         self
-+
+    }
     /// <p>The target type which defines the kinds of resources the document can run on. For example, <code>/AWS::EC2::Instance</code>. For a list of valid resource types, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html">Amazon Web Services resource and property types reference</a> in the <i>CloudFormation User Guide</i>.</p>
     pub fn get_target_type(&self) -> &::std::option::Option<::std::string::String> {
         &self.target_type
-+
+    }
     /// Appends an item to `tags`.
     ///
     /// To override the contents of this collection use [`set_tags`](Self::set_tags).
     ///
     /// <p>The tags, or metadata, that have been applied to the document.</p>
     pub fn tags(mut self, input: crate::types::Tag) -> Self {
         let mut v = self.tags.unwrap_or_default();
         v.push(input);
         self.tags = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>The tags, or metadata, that have been applied to the document.</p>
     pub fn set_tags(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>) -> Self {
         self.tags = input;
         self
-+
+    }
     /// <p>The tags, or metadata, that have been applied to the document.</p>
     pub fn get_tags(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Tag>> {
         &self.tags
-+
+    }
     /// Appends an item to `requires`.
     ///
     /// To override the contents of this collection use [`set_requires`](Self::set_requires).
     ///
     /// <p>A list of SSM documents required by a document. For example, an <code>ApplicationConfiguration</code> document requires an <code>ApplicationConfigurationSchema</code> document.</p>
     pub fn requires(mut self, input: crate::types::DocumentRequires) -> Self {
         let mut v = self.requires.unwrap_or_default();
         v.push(input);
         self.requires = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>A list of SSM documents required by a document. For example, an <code>ApplicationConfiguration</code> document requires an <code>ApplicationConfigurationSchema</code> document.</p>
     pub fn set_requires(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::DocumentRequires>>) -> Self {
         self.requires = input;
         self
-+
+    }
     /// <p>A list of SSM documents required by a document. For example, an <code>ApplicationConfiguration</code> document requires an <code>ApplicationConfigurationSchema</code> document.</p>
     pub fn get_requires(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::DocumentRequires>> {
         &self.requires
-+
+    }
     /// <p>The current status of a document review.</p>
     pub fn review_status(mut self, input: crate::types::ReviewStatus) -> Self {
         self.review_status = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>The current status of a document review.</p>
     pub fn set_review_status(mut self, input: ::std::option::Option<crate::types::ReviewStatus>) -> Self {
         self.review_status = input;
         self
-+
+    }
     /// <p>The current status of a document review.</p>
     pub fn get_review_status(&self) -> &::std::option::Option<crate::types::ReviewStatus> {
         &self.review_status
-+
+    }
     /// <p>The user in your organization who created the document.</p>
     pub fn author(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.author = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The user in your organization who created the document.</p>
     pub fn set_author(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.author = input;
         self
-+
+    }
     /// <p>The user in your organization who created the document.</p>
     pub fn get_author(&self) -> &::std::option::Option<::std::string::String> {
         &self.author
-+
+    }
     /// Consumes the builder and constructs a [`DocumentIdentifier`](crate::types::DocumentIdentifier).
     pub fn build(self) -> crate::types::DocumentIdentifier {
         crate::types::DocumentIdentifier {
             name: self.name,
             created_date: self.created_date,
             display_name: self.display_name,
             owner: self.owner,
             version_name: self.version_name,
             platform_types: self.platform_types,
             document_version: self.document_version,
             document_type: self.document_type,
             schema_version: self.schema_version,
             document_format: self.document_format,
             target_type: self.target_type,
             tags: self.tags,
             requires: self.requires,
             review_status: self.review_status,
             author: self.author,
-+
+        }
-+
+    }
-+
+}

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