AWS SDK

AWS SDK

rev. 97ba95e6039d206ffea5b866ddc214d34f7f88c3

Files changed:

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

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

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

@@ -0,1 +0,413 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>One or more aggregators for viewing counts of OpsData using different dimensions such as <code>Source</code>, <code>CreatedTime</code>, or <code>Source and CreatedTime</code>, to name a few.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct OpsAggregator {
           7  +
    /// <p>Either a <code>Range</code> or <code>Count</code> aggregator for limiting an OpsData summary.</p>
           8  +
    pub aggregator_type: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>The data type name to use for viewing counts of OpsData.</p>
          10  +
    pub type_name: ::std::option::Option<::std::string::String>,
          11  +
    /// <p>The name of an OpsData attribute on which to limit the count of OpsData.</p>
          12  +
    pub attribute_name: ::std::option::Option<::std::string::String>,
          13  +
    /// <p>The aggregator value.</p>
          14  +
    pub values: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
          15  +
    /// <p>The aggregator filters.</p>
          16  +
    pub filters: ::std::option::Option<::std::vec::Vec<crate::types::OpsFilter>>,
          17  +
    /// <p>A nested aggregator for viewing counts of OpsData.</p>
          18  +
    pub aggregators: ::std::option::Option<::std::vec::Vec<crate::types::OpsAggregator>>,
          19  +
}
          20  +
impl OpsAggregator {
          21  +
    /// <p>Either a <code>Range</code> or <code>Count</code> aggregator for limiting an OpsData summary.</p>
          22  +
    pub fn aggregator_type(&self) -> ::std::option::Option<&str> {
          23  +
        self.aggregator_type.as_deref()
          24  +
    }
          25  +
    /// <p>The data type name to use for viewing counts of OpsData.</p>
          26  +
    pub fn type_name(&self) -> ::std::option::Option<&str> {
          27  +
        self.type_name.as_deref()
          28  +
    }
          29  +
    /// <p>The name of an OpsData attribute on which to limit the count of OpsData.</p>
          30  +
    pub fn attribute_name(&self) -> ::std::option::Option<&str> {
          31  +
        self.attribute_name.as_deref()
          32  +
    }
          33  +
    /// <p>The aggregator value.</p>
          34  +
    pub fn values(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
          35  +
        self.values.as_ref()
          36  +
    }
          37  +
    /// <p>The aggregator filters.</p>
          38  +
    ///
          39  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.filters.is_none()`.
          40  +
    pub fn filters(&self) -> &[crate::types::OpsFilter] {
          41  +
        self.filters.as_deref().unwrap_or_default()
          42  +
    }
          43  +
    /// <p>A nested aggregator for viewing counts of OpsData.</p>
          44  +
    ///
          45  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.aggregators.is_none()`.
          46  +
    pub fn aggregators(&self) -> &[crate::types::OpsAggregator] {
          47  +
        self.aggregators.as_deref().unwrap_or_default()
          48  +
    }
          49  +
}
          50  +
static OPSAGGREGATOR_MEMBER_AGGREGATOR_TYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          51  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregator$AggregatorType", "com.amazonaws.ssm", "OpsAggregator"),
          52  +
    ::aws_smithy_schema::ShapeType::String,
          53  +
    "AggregatorType",
          54  +
    0,
          55  +
);
          56  +
static OPSAGGREGATOR_MEMBER_TYPE_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          57  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregator$TypeName", "com.amazonaws.ssm", "OpsAggregator"),
          58  +
    ::aws_smithy_schema::ShapeType::String,
          59  +
    "TypeName",
          60  +
    1,
          61  +
);
          62  +
static OPSAGGREGATOR_MEMBER_ATTRIBUTE_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          63  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregator$AttributeName", "com.amazonaws.ssm", "OpsAggregator"),
          64  +
    ::aws_smithy_schema::ShapeType::String,
          65  +
    "AttributeName",
          66  +
    2,
          67  +
);
          68  +
static OPSAGGREGATOR_MEMBER_VALUES_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          69  +
    ::aws_smithy_schema::ShapeId::from_parts(
          70  +
        "com.amazonaws.ssm#OpsAggregatorValueMap$key",
          71  +
        "com.amazonaws.ssm",
          72  +
        "OpsAggregatorValueMap",
          73  +
    ),
          74  +
    ::aws_smithy_schema::ShapeType::String,
          75  +
    "key",
          76  +
    0,
          77  +
);
          78  +
static OPSAGGREGATOR_MEMBER_VALUES_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          79  +
    ::aws_smithy_schema::ShapeId::from_parts(
          80  +
        "com.amazonaws.ssm#OpsAggregatorValueMap$value",
          81  +
        "com.amazonaws.ssm",
          82  +
        "OpsAggregatorValueMap",
          83  +
    ),
          84  +
    ::aws_smithy_schema::ShapeType::String,
          85  +
    "value",
          86  +
    1,
          87  +
);
          88  +
static OPSAGGREGATOR_MEMBER_VALUES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          89  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregator$Values", "com.amazonaws.ssm", "OpsAggregator"),
          90  +
    ::aws_smithy_schema::ShapeType::Map,
          91  +
    "Values",
          92  +
    3,
          93  +
)
          94  +
.with_map_members(&OPSAGGREGATOR_MEMBER_VALUES_KEY, &OPSAGGREGATOR_MEMBER_VALUES_VALUE);
          95  +
static OPSAGGREGATOR_MEMBER_FILTERS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          96  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsFilterList$member", "com.amazonaws.ssm", "OpsFilterList"),
          97  +
    ::aws_smithy_schema::ShapeType::Structure,
          98  +
    "member",
          99  +
    0,
         100  +
)
         101  +
.with_xml_name("OpsFilter");
         102  +
static OPSAGGREGATOR_MEMBER_FILTERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         103  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregator$Filters", "com.amazonaws.ssm", "OpsAggregator"),
         104  +
    ::aws_smithy_schema::ShapeType::List,
         105  +
    "Filters",
         106  +
    4,
         107  +
)
         108  +
.with_list_member(&OPSAGGREGATOR_MEMBER_FILTERS_MEMBER);
         109  +
static OPSAGGREGATOR_MEMBER_AGGREGATORS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         110  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregatorList$member", "com.amazonaws.ssm", "OpsAggregatorList"),
         111  +
    ::aws_smithy_schema::ShapeType::Structure,
         112  +
    "member",
         113  +
    0,
         114  +
)
         115  +
.with_xml_name("Aggregator");
         116  +
static OPSAGGREGATOR_MEMBER_AGGREGATORS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         117  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregator$Aggregators", "com.amazonaws.ssm", "OpsAggregator"),
         118  +
    ::aws_smithy_schema::ShapeType::List,
         119  +
    "Aggregators",
         120  +
    5,
         121  +
)
         122  +
.with_list_member(&OPSAGGREGATOR_MEMBER_AGGREGATORS_MEMBER);
         123  +
static OPSAGGREGATOR_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         124  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsAggregator", "com.amazonaws.ssm", "OpsAggregator"),
         125  +
    ::aws_smithy_schema::ShapeType::Structure,
         126  +
    &[
         127  +
        &OPSAGGREGATOR_MEMBER_AGGREGATOR_TYPE,
         128  +
        &OPSAGGREGATOR_MEMBER_TYPE_NAME,
         129  +
        &OPSAGGREGATOR_MEMBER_ATTRIBUTE_NAME,
         130  +
        &OPSAGGREGATOR_MEMBER_VALUES,
         131  +
        &OPSAGGREGATOR_MEMBER_FILTERS,
         132  +
        &OPSAGGREGATOR_MEMBER_AGGREGATORS,
         133  +
    ],
         134  +
);
         135  +
impl OpsAggregator {
         136  +
    /// The schema for this shape.
         137  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPSAGGREGATOR_SCHEMA;
         138  +
}
         139  +
impl ::aws_smithy_schema::serde::SerializableStruct for OpsAggregator {
         140  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         141  +
    fn serialize_members(
         142  +
        &self,
         143  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         144  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         145  +
        if let Some(ref val) = self.aggregator_type {
         146  +
            ser.write_string(&OPSAGGREGATOR_MEMBER_AGGREGATOR_TYPE, val)?;
         147  +
        }
         148  +
        if let Some(ref val) = self.type_name {
         149  +
            ser.write_string(&OPSAGGREGATOR_MEMBER_TYPE_NAME, val)?;
         150  +
        }
         151  +
        if let Some(ref val) = self.attribute_name {
         152  +
            ser.write_string(&OPSAGGREGATOR_MEMBER_ATTRIBUTE_NAME, val)?;
         153  +
        }
         154  +
        if let Some(ref val) = self.values {
         155  +
            ser.write_map(
         156  +
                &OPSAGGREGATOR_MEMBER_VALUES,
         157  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         158  +
                    for (key, value) in val {
         159  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         160  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
         161  +
                    }
         162  +
                    Ok(())
         163  +
                },
         164  +
            )?;
         165  +
        }
         166  +
        if let Some(ref val) = self.filters {
         167  +
            ser.write_list(
         168  +
                &OPSAGGREGATOR_MEMBER_FILTERS,
         169  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         170  +
                    for item in val {
         171  +
                        ser.write_struct(crate::types::OpsFilter::SCHEMA, item)?;
         172  +
                    }
         173  +
                    Ok(())
         174  +
                },
         175  +
            )?;
         176  +
        }
         177  +
        if let Some(ref val) = self.aggregators {
         178  +
            ser.write_list(
         179  +
                &OPSAGGREGATOR_MEMBER_AGGREGATORS,
         180  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         181  +
                    for item in val {
         182  +
                        ser.write_struct(crate::types::OpsAggregator::SCHEMA, item)?;
         183  +
                    }
         184  +
                    Ok(())
         185  +
                },
         186  +
            )?;
         187  +
        }
         188  +
        Ok(())
         189  +
    }
         190  +
}
         191  +
impl OpsAggregator {
         192  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         193  +
    pub fn deserialize(
         194  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         195  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         196  +
        #[allow(unused_variables, unused_mut)]
         197  +
        let mut builder = Self::builder();
         198  +
        #[allow(
         199  +
            unused_variables,
         200  +
            unreachable_code,
         201  +
            clippy::single_match,
         202  +
            clippy::match_single_binding,
         203  +
            clippy::diverging_sub_expression
         204  +
        )]
         205  +
        deserializer.read_struct(&OPSAGGREGATOR_SCHEMA, &mut |member, deser| {
         206  +
            match member.member_index() {
         207  +
                Some(0) => {
         208  +
                    if deser.is_null() {
         209  +
                        deser.read_null()?;
         210  +
                    } else {
         211  +
                        builder.aggregator_type = Some(deser.read_string(member)?);
         212  +
                    }
         213  +
                }
         214  +
                Some(1) => {
         215  +
                    if deser.is_null() {
         216  +
                        deser.read_null()?;
         217  +
                    } else {
         218  +
                        builder.type_name = Some(deser.read_string(member)?);
         219  +
                    }
         220  +
                }
         221  +
                Some(2) => {
         222  +
                    if deser.is_null() {
         223  +
                        deser.read_null()?;
         224  +
                    } else {
         225  +
                        builder.attribute_name = Some(deser.read_string(member)?);
         226  +
                    }
         227  +
                }
         228  +
                Some(3) => {
         229  +
                    if deser.is_null() {
         230  +
                        deser.read_null()?;
         231  +
                    } else {
         232  +
                        builder.values = Some(deser.read_string_string_map(member)?);
         233  +
                    }
         234  +
                }
         235  +
                Some(4) => {
         236  +
                    if deser.is_null() {
         237  +
                        deser.read_null()?;
         238  +
                    } else {
         239  +
                        builder.filters = Some({
         240  +
                            let mut container = Vec::new();
         241  +
                            deser.read_list(member, &mut |deser| {
         242  +
                                container.push(crate::types::OpsFilter::deserialize(deser)?);
         243  +
                                Ok(())
         244  +
                            })?;
         245  +
                            container
         246  +
                        });
         247  +
                    }
         248  +
                }
         249  +
                Some(5) => {
         250  +
                    if deser.is_null() {
         251  +
                        deser.read_null()?;
         252  +
                    } else {
         253  +
                        builder.aggregators = Some({
         254  +
                            let mut container = Vec::new();
         255  +
                            deser.read_list(member, &mut |deser| {
         256  +
                                container.push(crate::types::OpsAggregator::deserialize(deser)?);
         257  +
                                Ok(())
         258  +
                            })?;
         259  +
                            container
         260  +
                        });
         261  +
                    }
         262  +
                }
         263  +
                _ => {}
         264  +
            }
         265  +
            Ok(())
         266  +
        })?;
         267  +
        Ok(builder.build())
         268  +
    }
         269  +
}
         270  +
impl OpsAggregator {
         271  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         272  +
    pub fn deserialize_with_response(
         273  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         274  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         275  +
        _status: u16,
         276  +
        _body: &[u8],
         277  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         278  +
        Self::deserialize(deserializer)
         279  +
    }
         280  +
}
         281  +
impl OpsAggregator {
         282  +
    /// Creates a new builder-style object to manufacture [`OpsAggregator`](crate::types::OpsAggregator).
         283  +
    pub fn builder() -> crate::types::builders::OpsAggregatorBuilder {
         284  +
        crate::types::builders::OpsAggregatorBuilder::default()
         285  +
    }
         286  +
}
         287  +
         288  +
/// A builder for [`OpsAggregator`](crate::types::OpsAggregator).
         289  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         290  +
#[non_exhaustive]
         291  +
pub struct OpsAggregatorBuilder {
         292  +
    pub(crate) aggregator_type: ::std::option::Option<::std::string::String>,
         293  +
    pub(crate) type_name: ::std::option::Option<::std::string::String>,
         294  +
    pub(crate) attribute_name: ::std::option::Option<::std::string::String>,
         295  +
    pub(crate) values: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
         296  +
    pub(crate) filters: ::std::option::Option<::std::vec::Vec<crate::types::OpsFilter>>,
         297  +
    pub(crate) aggregators: ::std::option::Option<::std::vec::Vec<crate::types::OpsAggregator>>,
         298  +
}
         299  +
impl OpsAggregatorBuilder {
         300  +
    /// <p>Either a <code>Range</code> or <code>Count</code> aggregator for limiting an OpsData summary.</p>
         301  +
    pub fn aggregator_type(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         302  +
        self.aggregator_type = ::std::option::Option::Some(input.into());
         303  +
        self
         304  +
    }
         305  +
    /// <p>Either a <code>Range</code> or <code>Count</code> aggregator for limiting an OpsData summary.</p>
         306  +
    pub fn set_aggregator_type(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         307  +
        self.aggregator_type = input;
         308  +
        self
         309  +
    }
         310  +
    /// <p>Either a <code>Range</code> or <code>Count</code> aggregator for limiting an OpsData summary.</p>
         311  +
    pub fn get_aggregator_type(&self) -> &::std::option::Option<::std::string::String> {
         312  +
        &self.aggregator_type
         313  +
    }
         314  +
    /// <p>The data type name to use for viewing counts of OpsData.</p>
         315  +
    pub fn type_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         316  +
        self.type_name = ::std::option::Option::Some(input.into());
         317  +
        self
         318  +
    }
         319  +
    /// <p>The data type name to use for viewing counts of OpsData.</p>
         320  +
    pub fn set_type_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         321  +
        self.type_name = input;
         322  +
        self
         323  +
    }
         324  +
    /// <p>The data type name to use for viewing counts of OpsData.</p>
         325  +
    pub fn get_type_name(&self) -> &::std::option::Option<::std::string::String> {
         326  +
        &self.type_name
         327  +
    }
         328  +
    /// <p>The name of an OpsData attribute on which to limit the count of OpsData.</p>
         329  +
    pub fn attribute_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         330  +
        self.attribute_name = ::std::option::Option::Some(input.into());
         331  +
        self
         332  +
    }
         333  +
    /// <p>The name of an OpsData attribute on which to limit the count of OpsData.</p>
         334  +
    pub fn set_attribute_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         335  +
        self.attribute_name = input;
         336  +
        self
         337  +
    }
         338  +
    /// <p>The name of an OpsData attribute on which to limit the count of OpsData.</p>
         339  +
    pub fn get_attribute_name(&self) -> &::std::option::Option<::std::string::String> {
         340  +
        &self.attribute_name
         341  +
    }
         342  +
    /// Adds a key-value pair to `values`.
         343  +
    ///
         344  +
    /// To override the contents of this collection use [`set_values`](Self::set_values).
         345  +
    ///
         346  +
    /// <p>The aggregator value.</p>
         347  +
    pub fn values(mut self, k: impl ::std::convert::Into<::std::string::String>, v: impl ::std::convert::Into<::std::string::String>) -> Self {
         348  +
        let mut hash_map = self.values.unwrap_or_default();
         349  +
        hash_map.insert(k.into(), v.into());
         350  +
        self.values = ::std::option::Option::Some(hash_map);
         351  +
        self
         352  +
    }
         353  +
    /// <p>The aggregator value.</p>
         354  +
    pub fn set_values(mut self, input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>) -> Self {
         355  +
        self.values = input;
         356  +
        self
         357  +
    }
         358  +
    /// <p>The aggregator value.</p>
         359  +
    pub fn get_values(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         360  +
        &self.values
         361  +
    }
         362  +
    /// Appends an item to `filters`.
         363  +
    ///
         364  +
    /// To override the contents of this collection use [`set_filters`](Self::set_filters).
         365  +
    ///
         366  +
    /// <p>The aggregator filters.</p>
         367  +
    pub fn filters(mut self, input: crate::types::OpsFilter) -> Self {
         368  +
        let mut v = self.filters.unwrap_or_default();
         369  +
        v.push(input);
         370  +
        self.filters = ::std::option::Option::Some(v);
         371  +
        self
         372  +
    }
         373  +
    /// <p>The aggregator filters.</p>
         374  +
    pub fn set_filters(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::OpsFilter>>) -> Self {
         375  +
        self.filters = input;
         376  +
        self
         377  +
    }
         378  +
    /// <p>The aggregator filters.</p>
         379  +
    pub fn get_filters(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::OpsFilter>> {
         380  +
        &self.filters
         381  +
    }
         382  +
    /// Appends an item to `aggregators`.
         383  +
    ///
         384  +
    /// To override the contents of this collection use [`set_aggregators`](Self::set_aggregators).
         385  +
    ///
         386  +
    /// <p>A nested aggregator for viewing counts of OpsData.</p>
         387  +
    pub fn aggregators(mut self, input: crate::types::OpsAggregator) -> Self {
         388  +
        let mut v = self.aggregators.unwrap_or_default();
         389  +
        v.push(input);
         390  +
        self.aggregators = ::std::option::Option::Some(v);
         391  +
        self
         392  +
    }
         393  +
    /// <p>A nested aggregator for viewing counts of OpsData.</p>
         394  +
    pub fn set_aggregators(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::OpsAggregator>>) -> Self {
         395  +
        self.aggregators = input;
         396  +
        self
         397  +
    }
         398  +
    /// <p>A nested aggregator for viewing counts of OpsData.</p>
         399  +
    pub fn get_aggregators(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::OpsAggregator>> {
         400  +
        &self.aggregators
         401  +
    }
         402  +
    /// Consumes the builder and constructs a [`OpsAggregator`](crate::types::OpsAggregator).
         403  +
    pub fn build(self) -> crate::types::OpsAggregator {
         404  +
        crate::types::OpsAggregator {
         405  +
            aggregator_type: self.aggregator_type,
         406  +
            type_name: self.type_name,
         407  +
            attribute_name: self.attribute_name,
         408  +
            values: self.values,
         409  +
            filters: self.filters,
         410  +
            aggregators: self.aggregators,
         411  +
        }
         412  +
    }
         413  +
}

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

@@ -0,1 +0,188 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>The result of the query.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct OpsEntity {
           7  +
    /// <p>The query ID.</p>
           8  +
    pub id: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>The data returned by the query.</p>
          10  +
    pub data: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::OpsEntityItem>>,
          11  +
}
          12  +
impl OpsEntity {
          13  +
    /// <p>The query ID.</p>
          14  +
    pub fn id(&self) -> ::std::option::Option<&str> {
          15  +
        self.id.as_deref()
          16  +
    }
          17  +
    /// <p>The data returned by the query.</p>
          18  +
    pub fn data(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::OpsEntityItem>> {
          19  +
        self.data.as_ref()
          20  +
    }
          21  +
}
          22  +
static OPSENTITY_MEMBER_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          23  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntity$Id", "com.amazonaws.ssm", "OpsEntity"),
          24  +
    ::aws_smithy_schema::ShapeType::String,
          25  +
    "Id",
          26  +
    0,
          27  +
);
          28  +
static OPSENTITY_MEMBER_DATA_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          29  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntityItemMap$key", "com.amazonaws.ssm", "OpsEntityItemMap"),
          30  +
    ::aws_smithy_schema::ShapeType::String,
          31  +
    "key",
          32  +
    0,
          33  +
);
          34  +
static OPSENTITY_MEMBER_DATA_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          35  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntityItemMap$value", "com.amazonaws.ssm", "OpsEntityItemMap"),
          36  +
    ::aws_smithy_schema::ShapeType::Structure,
          37  +
    "value",
          38  +
    1,
          39  +
);
          40  +
static OPSENTITY_MEMBER_DATA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          41  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntity$Data", "com.amazonaws.ssm", "OpsEntity"),
          42  +
    ::aws_smithy_schema::ShapeType::Map,
          43  +
    "Data",
          44  +
    1,
          45  +
)
          46  +
.with_map_members(&OPSENTITY_MEMBER_DATA_KEY, &OPSENTITY_MEMBER_DATA_VALUE);
          47  +
static OPSENTITY_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          48  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntity", "com.amazonaws.ssm", "OpsEntity"),
          49  +
    ::aws_smithy_schema::ShapeType::Structure,
          50  +
    &[&OPSENTITY_MEMBER_ID, &OPSENTITY_MEMBER_DATA],
          51  +
);
          52  +
impl OpsEntity {
          53  +
    /// The schema for this shape.
          54  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPSENTITY_SCHEMA;
          55  +
}
          56  +
impl ::aws_smithy_schema::serde::SerializableStruct for OpsEntity {
          57  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          58  +
    fn serialize_members(
          59  +
        &self,
          60  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          61  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          62  +
        if let Some(ref val) = self.id {
          63  +
            ser.write_string(&OPSENTITY_MEMBER_ID, val)?;
          64  +
        }
          65  +
        if let Some(ref val) = self.data {
          66  +
            ser.write_map(&OPSENTITY_MEMBER_DATA, &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          67  +
                for (key, value) in val {
          68  +
                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
          69  +
                    ser.write_struct(crate::types::OpsEntityItem::SCHEMA, value)?;
          70  +
                }
          71  +
                Ok(())
          72  +
            })?;
          73  +
        }
          74  +
        Ok(())
          75  +
    }
          76  +
}
          77  +
impl OpsEntity {
          78  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          79  +
    pub fn deserialize(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          82  +
        #[allow(unused_variables, unused_mut)]
          83  +
        let mut builder = Self::builder();
          84  +
        #[allow(
          85  +
            unused_variables,
          86  +
            unreachable_code,
          87  +
            clippy::single_match,
          88  +
            clippy::match_single_binding,
          89  +
            clippy::diverging_sub_expression
          90  +
        )]
          91  +
        deserializer.read_struct(&OPSENTITY_SCHEMA, &mut |member, deser| {
          92  +
            match member.member_index() {
          93  +
                Some(0) => {
          94  +
                    if deser.is_null() {
          95  +
                        deser.read_null()?;
          96  +
                    } else {
          97  +
                        builder.id = Some(deser.read_string(member)?);
          98  +
                    }
          99  +
                }
         100  +
                Some(1) => {
         101  +
                    if deser.is_null() {
         102  +
                        deser.read_null()?;
         103  +
                    } else {
         104  +
                        builder.data = Some({
         105  +
                            let mut container = std::collections::HashMap::new();
         106  +
                            deser.read_map(member, &mut |key, deser| {
         107  +
                                container.insert(key, crate::types::OpsEntityItem::deserialize(deser)?);
         108  +
                                Ok(())
         109  +
                            })?;
         110  +
                            container
         111  +
                        });
         112  +
                    }
         113  +
                }
         114  +
                _ => {}
         115  +
            }
         116  +
            Ok(())
         117  +
        })?;
         118  +
        Ok(builder.build())
         119  +
    }
         120  +
}
         121  +
impl OpsEntity {
         122  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         123  +
    pub fn deserialize_with_response(
         124  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         125  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         126  +
        _status: u16,
         127  +
        _body: &[u8],
         128  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         129  +
        Self::deserialize(deserializer)
         130  +
    }
         131  +
}
         132  +
impl OpsEntity {
         133  +
    /// Creates a new builder-style object to manufacture [`OpsEntity`](crate::types::OpsEntity).
         134  +
    pub fn builder() -> crate::types::builders::OpsEntityBuilder {
         135  +
        crate::types::builders::OpsEntityBuilder::default()
         136  +
    }
         137  +
}
         138  +
         139  +
/// A builder for [`OpsEntity`](crate::types::OpsEntity).
         140  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         141  +
#[non_exhaustive]
         142  +
pub struct OpsEntityBuilder {
         143  +
    pub(crate) id: ::std::option::Option<::std::string::String>,
         144  +
    pub(crate) data: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::OpsEntityItem>>,
         145  +
}
         146  +
impl OpsEntityBuilder {
         147  +
    /// <p>The query ID.</p>
         148  +
    pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         149  +
        self.id = ::std::option::Option::Some(input.into());
         150  +
        self
         151  +
    }
         152  +
    /// <p>The query ID.</p>
         153  +
    pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         154  +
        self.id = input;
         155  +
        self
         156  +
    }
         157  +
    /// <p>The query ID.</p>
         158  +
    pub fn get_id(&self) -> &::std::option::Option<::std::string::String> {
         159  +
        &self.id
         160  +
    }
         161  +
    /// Adds a key-value pair to `data`.
         162  +
    ///
         163  +
    /// To override the contents of this collection use [`set_data`](Self::set_data).
         164  +
    ///
         165  +
    /// <p>The data returned by the query.</p>
         166  +
    pub fn data(mut self, k: impl ::std::convert::Into<::std::string::String>, v: crate::types::OpsEntityItem) -> Self {
         167  +
        let mut hash_map = self.data.unwrap_or_default();
         168  +
        hash_map.insert(k.into(), v);
         169  +
        self.data = ::std::option::Option::Some(hash_map);
         170  +
        self
         171  +
    }
         172  +
    /// <p>The data returned by the query.</p>
         173  +
    pub fn set_data(mut self, input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::OpsEntityItem>>) -> Self {
         174  +
        self.data = input;
         175  +
        self
         176  +
    }
         177  +
    /// <p>The data returned by the query.</p>
         178  +
    pub fn get_data(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::OpsEntityItem>> {
         179  +
        &self.data
         180  +
    }
         181  +
    /// Consumes the builder and constructs a [`OpsEntity`](crate::types::OpsEntity).
         182  +
    pub fn build(self) -> crate::types::OpsEntity {
         183  +
        crate::types::OpsEntity {
         184  +
            id: self.id,
         185  +
            data: self.data,
         186  +
        }
         187  +
    }
         188  +
}

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

@@ -0,1 +0,223 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>The OpsData summary.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct OpsEntityItem {
           7  +
    /// <p>The time the OpsData was captured.</p>
           8  +
    pub capture_time: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>The details of an OpsData summary.</p>
          10  +
    pub content: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>>,
          11  +
}
          12  +
impl OpsEntityItem {
          13  +
    /// <p>The time the OpsData was captured.</p>
          14  +
    pub fn capture_time(&self) -> ::std::option::Option<&str> {
          15  +
        self.capture_time.as_deref()
          16  +
    }
          17  +
    /// <p>The details of an OpsData summary.</p>
          18  +
    ///
          19  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.content.is_none()`.
          20  +
    pub fn content(&self) -> &[::std::collections::HashMap<::std::string::String, ::std::string::String>] {
          21  +
        self.content.as_deref().unwrap_or_default()
          22  +
    }
          23  +
}
          24  +
static OPSENTITYITEM_MEMBER_CAPTURE_TIME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          25  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntityItem$CaptureTime", "com.amazonaws.ssm", "OpsEntityItem"),
          26  +
    ::aws_smithy_schema::ShapeType::String,
          27  +
    "CaptureTime",
          28  +
    0,
          29  +
);
          30  +
static OPSENTITYITEM_MEMBER_CONTENT_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          31  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntityItemEntry$key", "com.amazonaws.ssm", "OpsEntityItemEntry"),
          32  +
    ::aws_smithy_schema::ShapeType::String,
          33  +
    "key",
          34  +
    0,
          35  +
);
          36  +
static OPSENTITYITEM_MEMBER_CONTENT_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          37  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntityItemEntry$value", "com.amazonaws.ssm", "OpsEntityItemEntry"),
          38  +
    ::aws_smithy_schema::ShapeType::String,
          39  +
    "value",
          40  +
    1,
          41  +
);
          42  +
static OPSENTITYITEM_MEMBER_CONTENT_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          43  +
    ::aws_smithy_schema::ShapeId::from_parts(
          44  +
        "com.amazonaws.ssm#OpsEntityItemEntryList$member",
          45  +
        "com.amazonaws.ssm",
          46  +
        "OpsEntityItemEntryList",
          47  +
    ),
          48  +
    ::aws_smithy_schema::ShapeType::Map,
          49  +
    "member",
          50  +
    0,
          51  +
)
          52  +
.with_map_members(&OPSENTITYITEM_MEMBER_CONTENT_MEMBER_KEY, &OPSENTITYITEM_MEMBER_CONTENT_MEMBER_VALUE);
          53  +
static OPSENTITYITEM_MEMBER_CONTENT: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          54  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntityItem$Content", "com.amazonaws.ssm", "OpsEntityItem"),
          55  +
    ::aws_smithy_schema::ShapeType::List,
          56  +
    "Content",
          57  +
    1,
          58  +
)
          59  +
.with_list_member(&OPSENTITYITEM_MEMBER_CONTENT_MEMBER);
          60  +
static OPSENTITYITEM_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          61  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsEntityItem", "com.amazonaws.ssm", "OpsEntityItem"),
          62  +
    ::aws_smithy_schema::ShapeType::Structure,
          63  +
    &[&OPSENTITYITEM_MEMBER_CAPTURE_TIME, &OPSENTITYITEM_MEMBER_CONTENT],
          64  +
);
          65  +
impl OpsEntityItem {
          66  +
    /// The schema for this shape.
          67  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPSENTITYITEM_SCHEMA;
          68  +
}
          69  +
impl ::aws_smithy_schema::serde::SerializableStruct for OpsEntityItem {
          70  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          71  +
    fn serialize_members(
          72  +
        &self,
          73  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          74  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          75  +
        if let Some(ref val) = self.capture_time {
          76  +
            ser.write_string(&OPSENTITYITEM_MEMBER_CAPTURE_TIME, val)?;
          77  +
        }
          78  +
        if let Some(ref val) = self.content {
          79  +
            ser.write_list(
          80  +
                &OPSENTITYITEM_MEMBER_CONTENT,
          81  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          82  +
                    for item in val {
          83  +
                        ser.write_map(
          84  +
                            &OPSENTITYITEM_MEMBER_CONTENT_MEMBER,
          85  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          86  +
                                for (key, value) in item {
          87  +
                                    ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
          88  +
                                    ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
          89  +
                                }
          90  +
                                Ok(())
          91  +
                            },
          92  +
                        )?;
          93  +
                    }
          94  +
                    Ok(())
          95  +
                },
          96  +
            )?;
          97  +
        }
          98  +
        Ok(())
          99  +
    }
         100  +
}
         101  +
impl OpsEntityItem {
         102  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         103  +
    pub fn deserialize(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         105  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         106  +
        #[allow(unused_variables, unused_mut)]
         107  +
        let mut builder = Self::builder();
         108  +
        #[allow(
         109  +
            unused_variables,
         110  +
            unreachable_code,
         111  +
            clippy::single_match,
         112  +
            clippy::match_single_binding,
         113  +
            clippy::diverging_sub_expression
         114  +
        )]
         115  +
        deserializer.read_struct(&OPSENTITYITEM_SCHEMA, &mut |member, deser| {
         116  +
            match member.member_index() {
         117  +
                Some(0) => {
         118  +
                    if deser.is_null() {
         119  +
                        deser.read_null()?;
         120  +
                    } else {
         121  +
                        builder.capture_time = Some(deser.read_string(member)?);
         122  +
                    }
         123  +
                }
         124  +
                Some(1) => {
         125  +
                    if deser.is_null() {
         126  +
                        deser.read_null()?;
         127  +
                    } else {
         128  +
                        builder.content = Some({
         129  +
                            let mut container = Vec::new();
         130  +
                            deser.read_list(member, &mut |deser| {
         131  +
                                container.push({
         132  +
                                    let mut map = ::std::collections::HashMap::new();
         133  +
                                    deser.read_map(&OPSENTITYITEM_MEMBER_CONTENT_MEMBER, &mut |key, deser| {
         134  +
                                        let value = deser.read_string(&::aws_smithy_schema::prelude::STRING)?;
         135  +
                                        map.insert(key, value);
         136  +
                                        Ok(())
         137  +
                                    })?;
         138  +
                                    map
         139  +
                                });
         140  +
                                Ok(())
         141  +
                            })?;
         142  +
                            container
         143  +
                        });
         144  +
                    }
         145  +
                }
         146  +
                _ => {}
         147  +
            }
         148  +
            Ok(())
         149  +
        })?;
         150  +
        Ok(builder.build())
         151  +
    }
         152  +
}
         153  +
impl OpsEntityItem {
         154  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         155  +
    pub fn deserialize_with_response(
         156  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         157  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         158  +
        _status: u16,
         159  +
        _body: &[u8],
         160  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         161  +
        Self::deserialize(deserializer)
         162  +
    }
         163  +
}
         164  +
impl OpsEntityItem {
         165  +
    /// Creates a new builder-style object to manufacture [`OpsEntityItem`](crate::types::OpsEntityItem).
         166  +
    pub fn builder() -> crate::types::builders::OpsEntityItemBuilder {
         167  +
        crate::types::builders::OpsEntityItemBuilder::default()
         168  +
    }
         169  +
}
         170  +
         171  +
/// A builder for [`OpsEntityItem`](crate::types::OpsEntityItem).
         172  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         173  +
#[non_exhaustive]
         174  +
pub struct OpsEntityItemBuilder {
         175  +
    pub(crate) capture_time: ::std::option::Option<::std::string::String>,
         176  +
    pub(crate) content: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>>,
         177  +
}
         178  +
impl OpsEntityItemBuilder {
         179  +
    /// <p>The time the OpsData was captured.</p>
         180  +
    pub fn capture_time(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         181  +
        self.capture_time = ::std::option::Option::Some(input.into());
         182  +
        self
         183  +
    }
         184  +
    /// <p>The time the OpsData was captured.</p>
         185  +
    pub fn set_capture_time(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         186  +
        self.capture_time = input;
         187  +
        self
         188  +
    }
         189  +
    /// <p>The time the OpsData was captured.</p>
         190  +
    pub fn get_capture_time(&self) -> &::std::option::Option<::std::string::String> {
         191  +
        &self.capture_time
         192  +
    }
         193  +
    /// Appends an item to `content`.
         194  +
    ///
         195  +
    /// To override the contents of this collection use [`set_content`](Self::set_content).
         196  +
    ///
         197  +
    /// <p>The details of an OpsData summary.</p>
         198  +
    pub fn content(mut self, input: ::std::collections::HashMap<::std::string::String, ::std::string::String>) -> Self {
         199  +
        let mut v = self.content.unwrap_or_default();
         200  +
        v.push(input);
         201  +
        self.content = ::std::option::Option::Some(v);
         202  +
        self
         203  +
    }
         204  +
    /// <p>The details of an OpsData summary.</p>
         205  +
    pub fn set_content(
         206  +
        mut self,
         207  +
        input: ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>>,
         208  +
    ) -> Self {
         209  +
        self.content = input;
         210  +
        self
         211  +
    }
         212  +
    /// <p>The details of an OpsData summary.</p>
         213  +
    pub fn get_content(&self) -> &::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>> {
         214  +
        &self.content
         215  +
    }
         216  +
    /// Consumes the builder and constructs a [`OpsEntityItem`](crate::types::OpsEntityItem).
         217  +
    pub fn build(self) -> crate::types::OpsEntityItem {
         218  +
        crate::types::OpsEntityItem {
         219  +
            capture_time: self.capture_time,
         220  +
            content: self.content,
         221  +
        }
         222  +
    }
         223  +
}