AWS SDK

AWS SDK

rev. 3388bf5e18f4269f2b46f39cdc814c5c39d413d0 (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -0,1 +0,177 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Describes a filter.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct AssociationFilter {
           7  +
    /// <p>The name of the filter.</p><note>
           8  +
    /// <p><code>InstanceId</code> has been deprecated.</p>
           9  +
    /// </note>
          10  +
    pub key: crate::types::AssociationFilterKey,
          11  +
    /// <p>The filter value.</p>
          12  +
    pub value: ::std::string::String,
          13  +
}
          14  +
impl AssociationFilter {
          15  +
    /// <p>The name of the filter.</p><note>
          16  +
    /// <p><code>InstanceId</code> has been deprecated.</p>
          17  +
    /// </note>
          18  +
    pub fn key(&self) -> &crate::types::AssociationFilterKey {
          19  +
        &self.key
          20  +
    }
          21  +
    /// <p>The filter value.</p>
          22  +
    pub fn value(&self) -> &str {
          23  +
        use std::ops::Deref;
          24  +
        self.value.deref()
          25  +
    }
          26  +
}
          27  +
static ASSOCIATIONFILTER_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          28  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationFilter$key", "com.amazonaws.ssm", "AssociationFilter"),
          29  +
    ::aws_smithy_schema::ShapeType::String,
          30  +
    "key",
          31  +
    0,
          32  +
);
          33  +
static ASSOCIATIONFILTER_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationFilter$value", "com.amazonaws.ssm", "AssociationFilter"),
          35  +
    ::aws_smithy_schema::ShapeType::String,
          36  +
    "value",
          37  +
    1,
          38  +
);
          39  +
static ASSOCIATIONFILTER_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          40  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationFilter", "com.amazonaws.ssm", "AssociationFilter"),
          41  +
    ::aws_smithy_schema::ShapeType::Structure,
          42  +
    &[&ASSOCIATIONFILTER_MEMBER_KEY, &ASSOCIATIONFILTER_MEMBER_VALUE],
          43  +
);
          44  +
impl AssociationFilter {
          45  +
    /// The schema for this shape.
          46  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &ASSOCIATIONFILTER_SCHEMA;
          47  +
}
          48  +
impl ::aws_smithy_schema::serde::SerializableStruct for AssociationFilter {
          49  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          50  +
    fn serialize_members(
          51  +
        &self,
          52  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          53  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          54  +
        {
          55  +
            let val = &self.key;
          56  +
            ser.write_string(&ASSOCIATIONFILTER_MEMBER_KEY, val.as_str())?;
          57  +
        }
          58  +
        {
          59  +
            let val = &self.value;
          60  +
            ser.write_string(&ASSOCIATIONFILTER_MEMBER_VALUE, val)?;
          61  +
        }
          62  +
        Ok(())
          63  +
    }
          64  +
}
          65  +
impl AssociationFilter {
          66  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          67  +
    pub fn deserialize(
          68  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          69  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          70  +
        #[allow(unused_variables, unused_mut)]
          71  +
        let mut builder = Self::builder();
          72  +
        #[allow(
          73  +
            unused_variables,
          74  +
            unreachable_code,
          75  +
            clippy::single_match,
          76  +
            clippy::match_single_binding,
          77  +
            clippy::diverging_sub_expression
          78  +
        )]
          79  +
        deserializer.read_struct(&ASSOCIATIONFILTER_SCHEMA, &mut |member, deser| {
          80  +
            match member.member_index() {
          81  +
                Some(0) => {
          82  +
                    builder.key = Some(crate::types::AssociationFilterKey::from(deser.read_string(member)?.as_str()));
          83  +
                }
          84  +
                Some(1) => {
          85  +
                    builder.value = Some(deser.read_string(member)?);
          86  +
                }
          87  +
                _ => {}
          88  +
            }
          89  +
            Ok(())
          90  +
        })?;
          91  +
        builder.value = builder.value.or(Some(String::new()));
          92  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
          93  +
    }
          94  +
}
          95  +
impl AssociationFilter {
          96  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          97  +
    pub fn deserialize_with_response(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          99  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         100  +
        _status: u16,
         101  +
        _body: &[u8],
         102  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         103  +
        Self::deserialize(deserializer)
         104  +
    }
         105  +
}
         106  +
impl AssociationFilter {
         107  +
    /// Creates a new builder-style object to manufacture [`AssociationFilter`](crate::types::AssociationFilter).
         108  +
    pub fn builder() -> crate::types::builders::AssociationFilterBuilder {
         109  +
        crate::types::builders::AssociationFilterBuilder::default()
         110  +
    }
         111  +
}
         112  +
         113  +
/// A builder for [`AssociationFilter`](crate::types::AssociationFilter).
         114  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         115  +
#[non_exhaustive]
         116  +
pub struct AssociationFilterBuilder {
         117  +
    pub(crate) key: ::std::option::Option<crate::types::AssociationFilterKey>,
         118  +
    pub(crate) value: ::std::option::Option<::std::string::String>,
         119  +
}
         120  +
impl AssociationFilterBuilder {
         121  +
    /// <p>The name of the filter.</p><note>
         122  +
    /// <p><code>InstanceId</code> has been deprecated.</p>
         123  +
    /// </note>
         124  +
    /// This field is required.
         125  +
    pub fn key(mut self, input: crate::types::AssociationFilterKey) -> Self {
         126  +
        self.key = ::std::option::Option::Some(input);
         127  +
        self
         128  +
    }
         129  +
    /// <p>The name of the filter.</p><note>
         130  +
    /// <p><code>InstanceId</code> has been deprecated.</p>
         131  +
    /// </note>
         132  +
    pub fn set_key(mut self, input: ::std::option::Option<crate::types::AssociationFilterKey>) -> Self {
         133  +
        self.key = input;
         134  +
        self
         135  +
    }
         136  +
    /// <p>The name of the filter.</p><note>
         137  +
    /// <p><code>InstanceId</code> has been deprecated.</p>
         138  +
    /// </note>
         139  +
    pub fn get_key(&self) -> &::std::option::Option<crate::types::AssociationFilterKey> {
         140  +
        &self.key
         141  +
    }
         142  +
    /// <p>The filter value.</p>
         143  +
    /// This field is required.
         144  +
    pub fn value(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         145  +
        self.value = ::std::option::Option::Some(input.into());
         146  +
        self
         147  +
    }
         148  +
    /// <p>The filter value.</p>
         149  +
    pub fn set_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         150  +
        self.value = input;
         151  +
        self
         152  +
    }
         153  +
    /// <p>The filter value.</p>
         154  +
    pub fn get_value(&self) -> &::std::option::Option<::std::string::String> {
         155  +
        &self.value
         156  +
    }
         157  +
    /// Consumes the builder and constructs a [`AssociationFilter`](crate::types::AssociationFilter).
         158  +
    /// This method will fail if any of the following fields are not set:
         159  +
    /// - [`key`](crate::types::builders::AssociationFilterBuilder::key)
         160  +
    /// - [`value`](crate::types::builders::AssociationFilterBuilder::value)
         161  +
    pub fn build(self) -> ::std::result::Result<crate::types::AssociationFilter, ::aws_smithy_types::error::operation::BuildError> {
         162  +
        ::std::result::Result::Ok(crate::types::AssociationFilter {
         163  +
            key: self.key.ok_or_else(|| {
         164  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
         165  +
                    "key",
         166  +
                    "key was not specified but it is required when building AssociationFilter",
         167  +
                )
         168  +
            })?,
         169  +
            value: self.value.ok_or_else(|| {
         170  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
         171  +
                    "value",
         172  +
                    "value was not specified but it is required when building AssociationFilter",
         173  +
                )
         174  +
            })?,
         175  +
        })
         176  +
    }
         177  +
}

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

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

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

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

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

@@ -0,1 +0,258 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Information about the association.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct AssociationOverview {
           7  +
    /// <p>The status of the association. Status can be: Pending, Success, or Failed.</p>
           8  +
    pub status: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>A detailed status of the association.</p>
          10  +
    pub detailed_status: ::std::option::Option<::std::string::String>,
          11  +
    /// <p>Returns the number of targets for the association status. For example, if you created an association with two managed nodes, and one of them was successful, this would return the count of managed nodes by status.</p>
          12  +
    pub association_status_aggregated_count: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
          13  +
}
          14  +
impl AssociationOverview {
          15  +
    /// <p>The status of the association. Status can be: Pending, Success, or Failed.</p>
          16  +
    pub fn status(&self) -> ::std::option::Option<&str> {
          17  +
        self.status.as_deref()
          18  +
    }
          19  +
    /// <p>A detailed status of the association.</p>
          20  +
    pub fn detailed_status(&self) -> ::std::option::Option<&str> {
          21  +
        self.detailed_status.as_deref()
          22  +
    }
          23  +
    /// <p>Returns the number of targets for the association status. For example, if you created an association with two managed nodes, and one of them was successful, this would return the count of managed nodes by status.</p>
          24  +
    pub fn association_status_aggregated_count(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, i32>> {
          25  +
        self.association_status_aggregated_count.as_ref()
          26  +
    }
          27  +
}
          28  +
static ASSOCIATIONOVERVIEW_MEMBER_STATUS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          29  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationOverview$Status", "com.amazonaws.ssm", "AssociationOverview"),
          30  +
    ::aws_smithy_schema::ShapeType::String,
          31  +
    "Status",
          32  +
    0,
          33  +
);
          34  +
static ASSOCIATIONOVERVIEW_MEMBER_DETAILED_STATUS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          35  +
    ::aws_smithy_schema::ShapeId::from_parts(
          36  +
        "com.amazonaws.ssm#AssociationOverview$DetailedStatus",
          37  +
        "com.amazonaws.ssm",
          38  +
        "AssociationOverview",
          39  +
    ),
          40  +
    ::aws_smithy_schema::ShapeType::String,
          41  +
    "DetailedStatus",
          42  +
    1,
          43  +
);
          44  +
static ASSOCIATIONOVERVIEW_MEMBER_ASSOCIATION_STATUS_AGGREGATED_COUNT_KEY: ::aws_smithy_schema::Schema<'static> =
          45  +
    ::aws_smithy_schema::Schema::new_member(
          46  +
        ::aws_smithy_schema::ShapeId::from_parts(
          47  +
            "com.amazonaws.ssm#AssociationStatusAggregatedCount$key",
          48  +
            "com.amazonaws.ssm",
          49  +
            "AssociationStatusAggregatedCount",
          50  +
        ),
          51  +
        ::aws_smithy_schema::ShapeType::String,
          52  +
        "key",
          53  +
        0,
          54  +
    );
          55  +
static ASSOCIATIONOVERVIEW_MEMBER_ASSOCIATION_STATUS_AGGREGATED_COUNT_VALUE: ::aws_smithy_schema::Schema<'static> =
          56  +
    ::aws_smithy_schema::Schema::new_member(
          57  +
        ::aws_smithy_schema::ShapeId::from_parts(
          58  +
            "com.amazonaws.ssm#AssociationStatusAggregatedCount$value",
          59  +
            "com.amazonaws.ssm",
          60  +
            "AssociationStatusAggregatedCount",
          61  +
        ),
          62  +
        ::aws_smithy_schema::ShapeType::Integer,
          63  +
        "value",
          64  +
        1,
          65  +
    );
          66  +
static ASSOCIATIONOVERVIEW_MEMBER_ASSOCIATION_STATUS_AGGREGATED_COUNT: ::aws_smithy_schema::Schema<'static> =
          67  +
    ::aws_smithy_schema::Schema::new_member(
          68  +
        ::aws_smithy_schema::ShapeId::from_parts(
          69  +
            "com.amazonaws.ssm#AssociationOverview$AssociationStatusAggregatedCount",
          70  +
            "com.amazonaws.ssm",
          71  +
            "AssociationOverview",
          72  +
        ),
          73  +
        ::aws_smithy_schema::ShapeType::Map,
          74  +
        "AssociationStatusAggregatedCount",
          75  +
        2,
          76  +
    )
          77  +
    .with_map_members(
          78  +
        &ASSOCIATIONOVERVIEW_MEMBER_ASSOCIATION_STATUS_AGGREGATED_COUNT_KEY,
          79  +
        &ASSOCIATIONOVERVIEW_MEMBER_ASSOCIATION_STATUS_AGGREGATED_COUNT_VALUE,
          80  +
    );
          81  +
static ASSOCIATIONOVERVIEW_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          82  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#AssociationOverview", "com.amazonaws.ssm", "AssociationOverview"),
          83  +
    ::aws_smithy_schema::ShapeType::Structure,
          84  +
    &[
          85  +
        &ASSOCIATIONOVERVIEW_MEMBER_STATUS,
          86  +
        &ASSOCIATIONOVERVIEW_MEMBER_DETAILED_STATUS,
          87  +
        &ASSOCIATIONOVERVIEW_MEMBER_ASSOCIATION_STATUS_AGGREGATED_COUNT,
          88  +
    ],
          89  +
);
          90  +
impl AssociationOverview {
          91  +
    /// The schema for this shape.
          92  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &ASSOCIATIONOVERVIEW_SCHEMA;
          93  +
}
          94  +
impl ::aws_smithy_schema::serde::SerializableStruct for AssociationOverview {
          95  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          96  +
    fn serialize_members(
          97  +
        &self,
          98  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          99  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         100  +
        if let Some(ref val) = self.status {
         101  +
            ser.write_string(&ASSOCIATIONOVERVIEW_MEMBER_STATUS, val)?;
         102  +
        }
         103  +
        if let Some(ref val) = self.detailed_status {
         104  +
            ser.write_string(&ASSOCIATIONOVERVIEW_MEMBER_DETAILED_STATUS, val)?;
         105  +
        }
         106  +
        if let Some(ref val) = self.association_status_aggregated_count {
         107  +
            ser.write_map(
         108  +
                &ASSOCIATIONOVERVIEW_MEMBER_ASSOCIATION_STATUS_AGGREGATED_COUNT,
         109  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         110  +
                    for (key, value) in val {
         111  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         112  +
                        ser.write_integer(&::aws_smithy_schema::prelude::INTEGER, *value)?;
         113  +
                    }
         114  +
                    Ok(())
         115  +
                },
         116  +
            )?;
         117  +
        }
         118  +
        Ok(())
         119  +
    }
         120  +
}
         121  +
impl AssociationOverview {
         122  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         123  +
    pub fn deserialize(
         124  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         125  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         126  +
        #[allow(unused_variables, unused_mut)]
         127  +
        let mut builder = Self::builder();
         128  +
        #[allow(
         129  +
            unused_variables,
         130  +
            unreachable_code,
         131  +
            clippy::single_match,
         132  +
            clippy::match_single_binding,
         133  +
            clippy::diverging_sub_expression
         134  +
        )]
         135  +
        deserializer.read_struct(&ASSOCIATIONOVERVIEW_SCHEMA, &mut |member, deser| {
         136  +
            match member.member_index() {
         137  +
                Some(0) => {
         138  +
                    if deser.is_null() {
         139  +
                        deser.read_null()?;
         140  +
                    } else {
         141  +
                        builder.status = Some(deser.read_string(member)?);
         142  +
                    }
         143  +
                }
         144  +
                Some(1) => {
         145  +
                    if deser.is_null() {
         146  +
                        deser.read_null()?;
         147  +
                    } else {
         148  +
                        builder.detailed_status = Some(deser.read_string(member)?);
         149  +
                    }
         150  +
                }
         151  +
                Some(2) => {
         152  +
                    if deser.is_null() {
         153  +
                        deser.read_null()?;
         154  +
                    } else {
         155  +
                        builder.association_status_aggregated_count = Some({
         156  +
                            let mut container = std::collections::HashMap::new();
         157  +
                            deser.read_map(member, &mut |key, deser| {
         158  +
                                container.insert(key, deser.read_integer(&::aws_smithy_schema::prelude::INTEGER)?);
         159  +
                                Ok(())
         160  +
                            })?;
         161  +
                            container
         162  +
                        });
         163  +
                    }
         164  +
                }
         165  +
                _ => {}
         166  +
            }
         167  +
            Ok(())
         168  +
        })?;
         169  +
        Ok(builder.build())
         170  +
    }
         171  +
}
         172  +
impl AssociationOverview {
         173  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         174  +
    pub fn deserialize_with_response(
         175  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         176  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         177  +
        _status: u16,
         178  +
        _body: &[u8],
         179  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         180  +
        Self::deserialize(deserializer)
         181  +
    }
         182  +
}
         183  +
impl AssociationOverview {
         184  +
    /// Creates a new builder-style object to manufacture [`AssociationOverview`](crate::types::AssociationOverview).
         185  +
    pub fn builder() -> crate::types::builders::AssociationOverviewBuilder {
         186  +
        crate::types::builders::AssociationOverviewBuilder::default()
         187  +
    }
         188  +
}
         189  +
         190  +
/// A builder for [`AssociationOverview`](crate::types::AssociationOverview).
         191  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         192  +
#[non_exhaustive]
         193  +
pub struct AssociationOverviewBuilder {
         194  +
    pub(crate) status: ::std::option::Option<::std::string::String>,
         195  +
    pub(crate) detailed_status: ::std::option::Option<::std::string::String>,
         196  +
    pub(crate) association_status_aggregated_count: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
         197  +
}
         198  +
impl AssociationOverviewBuilder {
         199  +
    /// <p>The status of the association. Status can be: Pending, Success, or Failed.</p>
         200  +
    pub fn status(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         201  +
        self.status = ::std::option::Option::Some(input.into());
         202  +
        self
         203  +
    }
         204  +
    /// <p>The status of the association. Status can be: Pending, Success, or Failed.</p>
         205  +
    pub fn set_status(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         206  +
        self.status = input;
         207  +
        self
         208  +
    }
         209  +
    /// <p>The status of the association. Status can be: Pending, Success, or Failed.</p>
         210  +
    pub fn get_status(&self) -> &::std::option::Option<::std::string::String> {
         211  +
        &self.status
         212  +
    }
         213  +
    /// <p>A detailed status of the association.</p>
         214  +
    pub fn detailed_status(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         215  +
        self.detailed_status = ::std::option::Option::Some(input.into());
         216  +
        self
         217  +
    }
         218  +
    /// <p>A detailed status of the association.</p>
         219  +
    pub fn set_detailed_status(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         220  +
        self.detailed_status = input;
         221  +
        self
         222  +
    }
         223  +
    /// <p>A detailed status of the association.</p>
         224  +
    pub fn get_detailed_status(&self) -> &::std::option::Option<::std::string::String> {
         225  +
        &self.detailed_status
         226  +
    }
         227  +
    /// Adds a key-value pair to `association_status_aggregated_count`.
         228  +
    ///
         229  +
    /// To override the contents of this collection use [`set_association_status_aggregated_count`](Self::set_association_status_aggregated_count).
         230  +
    ///
         231  +
    /// <p>Returns the number of targets for the association status. For example, if you created an association with two managed nodes, and one of them was successful, this would return the count of managed nodes by status.</p>
         232  +
    pub fn association_status_aggregated_count(mut self, k: impl ::std::convert::Into<::std::string::String>, v: i32) -> Self {
         233  +
        let mut hash_map = self.association_status_aggregated_count.unwrap_or_default();
         234  +
        hash_map.insert(k.into(), v);
         235  +
        self.association_status_aggregated_count = ::std::option::Option::Some(hash_map);
         236  +
        self
         237  +
    }
         238  +
    /// <p>Returns the number of targets for the association status. For example, if you created an association with two managed nodes, and one of them was successful, this would return the count of managed nodes by status.</p>
         239  +
    pub fn set_association_status_aggregated_count(
         240  +
        mut self,
         241  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, i32>>,
         242  +
    ) -> Self {
         243  +
        self.association_status_aggregated_count = input;
         244  +
        self
         245  +
    }
         246  +
    /// <p>Returns the number of targets for the association status. For example, if you created an association with two managed nodes, and one of them was successful, this would return the count of managed nodes by status.</p>
         247  +
    pub fn get_association_status_aggregated_count(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, i32>> {
         248  +
        &self.association_status_aggregated_count
         249  +
    }
         250  +
    /// Consumes the builder and constructs a [`AssociationOverview`](crate::types::AssociationOverview).
         251  +
    pub fn build(self) -> crate::types::AssociationOverview {
         252  +
        crate::types::AssociationOverview {
         253  +
            status: self.status,
         254  +
            detailed_status: self.detailed_status,
         255  +
            association_status_aggregated_count: self.association_status_aggregated_count,
         256  +
        }
         257  +
    }
         258  +
}