AWS SDK

AWS SDK

rev. 3388bf5e18f4269f2b46f39cdc814c5c39d413d0 (ignoring whitespace)

Files changed:

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

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

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

@@ -0,1 +0,156 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>An object that defines the value of the key and its type in the OperationalData map.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct OpsItemDataValue {
           7  +
    /// <p>The value of the OperationalData key.</p>
           8  +
    pub value: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>The type of key-value pair. Valid types include <code>SearchableString</code> and <code>String</code>.</p>
          10  +
    pub r#type: ::std::option::Option<crate::types::OpsItemDataType>,
          11  +
}
          12  +
impl OpsItemDataValue {
          13  +
    /// <p>The value of the OperationalData key.</p>
          14  +
    pub fn value(&self) -> ::std::option::Option<&str> {
          15  +
        self.value.as_deref()
          16  +
    }
          17  +
    /// <p>The type of key-value pair. Valid types include <code>SearchableString</code> and <code>String</code>.</p>
          18  +
    pub fn r#type(&self) -> ::std::option::Option<&crate::types::OpsItemDataType> {
          19  +
        self.r#type.as_ref()
          20  +
    }
          21  +
}
          22  +
static OPSITEMDATAVALUE_MEMBER_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          23  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemDataValue$Value", "com.amazonaws.ssm", "OpsItemDataValue"),
          24  +
    ::aws_smithy_schema::ShapeType::String,
          25  +
    "Value",
          26  +
    0,
          27  +
);
          28  +
static OPSITEMDATAVALUE_MEMBER_TYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          29  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemDataValue$Type", "com.amazonaws.ssm", "OpsItemDataValue"),
          30  +
    ::aws_smithy_schema::ShapeType::String,
          31  +
    "Type",
          32  +
    1,
          33  +
);
          34  +
static OPSITEMDATAVALUE_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          35  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemDataValue", "com.amazonaws.ssm", "OpsItemDataValue"),
          36  +
    ::aws_smithy_schema::ShapeType::Structure,
          37  +
    &[&OPSITEMDATAVALUE_MEMBER_VALUE, &OPSITEMDATAVALUE_MEMBER_TYPE],
          38  +
);
          39  +
impl OpsItemDataValue {
          40  +
    /// The schema for this shape.
          41  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPSITEMDATAVALUE_SCHEMA;
          42  +
}
          43  +
impl ::aws_smithy_schema::serde::SerializableStruct for OpsItemDataValue {
          44  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          45  +
    fn serialize_members(
          46  +
        &self,
          47  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          48  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          49  +
        if let Some(ref val) = self.value {
          50  +
            ser.write_string(&OPSITEMDATAVALUE_MEMBER_VALUE, val)?;
          51  +
        }
          52  +
        if let Some(ref val) = self.r#type {
          53  +
            ser.write_string(&OPSITEMDATAVALUE_MEMBER_TYPE, val.as_str())?;
          54  +
        }
          55  +
        Ok(())
          56  +
    }
          57  +
}
          58  +
impl OpsItemDataValue {
          59  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          60  +
    pub fn deserialize(
          61  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          62  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          63  +
        #[allow(unused_variables, unused_mut)]
          64  +
        let mut builder = Self::builder();
          65  +
        #[allow(
          66  +
            unused_variables,
          67  +
            unreachable_code,
          68  +
            clippy::single_match,
          69  +
            clippy::match_single_binding,
          70  +
            clippy::diverging_sub_expression
          71  +
        )]
          72  +
        deserializer.read_struct(&OPSITEMDATAVALUE_SCHEMA, &mut |member, deser| {
          73  +
            match member.member_index() {
          74  +
                Some(0) => {
          75  +
                    if deser.is_null() {
          76  +
                        deser.read_null()?;
          77  +
                    } else {
          78  +
                        builder.value = Some(deser.read_string(member)?);
          79  +
                    }
          80  +
                }
          81  +
                Some(1) => {
          82  +
                    if deser.is_null() {
          83  +
                        deser.read_null()?;
          84  +
                    } else {
          85  +
                        builder.r#type = Some(crate::types::OpsItemDataType::from(deser.read_string(member)?.as_str()));
          86  +
                    }
          87  +
                }
          88  +
                _ => {}
          89  +
            }
          90  +
            Ok(())
          91  +
        })?;
          92  +
        Ok(builder.build())
          93  +
    }
          94  +
}
          95  +
impl OpsItemDataValue {
          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 OpsItemDataValue {
         107  +
    /// Creates a new builder-style object to manufacture [`OpsItemDataValue`](crate::types::OpsItemDataValue).
         108  +
    pub fn builder() -> crate::types::builders::OpsItemDataValueBuilder {
         109  +
        crate::types::builders::OpsItemDataValueBuilder::default()
         110  +
    }
         111  +
}
         112  +
         113  +
/// A builder for [`OpsItemDataValue`](crate::types::OpsItemDataValue).
         114  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         115  +
#[non_exhaustive]
         116  +
pub struct OpsItemDataValueBuilder {
         117  +
    pub(crate) value: ::std::option::Option<::std::string::String>,
         118  +
    pub(crate) r#type: ::std::option::Option<crate::types::OpsItemDataType>,
         119  +
}
         120  +
impl OpsItemDataValueBuilder {
         121  +
    /// <p>The value of the OperationalData key.</p>
         122  +
    pub fn value(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         123  +
        self.value = ::std::option::Option::Some(input.into());
         124  +
        self
         125  +
    }
         126  +
    /// <p>The value of the OperationalData key.</p>
         127  +
    pub fn set_value(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         128  +
        self.value = input;
         129  +
        self
         130  +
    }
         131  +
    /// <p>The value of the OperationalData key.</p>
         132  +
    pub fn get_value(&self) -> &::std::option::Option<::std::string::String> {
         133  +
        &self.value
         134  +
    }
         135  +
    /// <p>The type of key-value pair. Valid types include <code>SearchableString</code> and <code>String</code>.</p>
         136  +
    pub fn r#type(mut self, input: crate::types::OpsItemDataType) -> Self {
         137  +
        self.r#type = ::std::option::Option::Some(input);
         138  +
        self
         139  +
    }
         140  +
    /// <p>The type of key-value pair. Valid types include <code>SearchableString</code> and <code>String</code>.</p>
         141  +
    pub fn set_type(mut self, input: ::std::option::Option<crate::types::OpsItemDataType>) -> Self {
         142  +
        self.r#type = input;
         143  +
        self
         144  +
    }
         145  +
    /// <p>The type of key-value pair. Valid types include <code>SearchableString</code> and <code>String</code>.</p>
         146  +
    pub fn get_type(&self) -> &::std::option::Option<crate::types::OpsItemDataType> {
         147  +
        &self.r#type
         148  +
    }
         149  +
    /// Consumes the builder and constructs a [`OpsItemDataValue`](crate::types::OpsItemDataValue).
         150  +
    pub fn build(self) -> crate::types::OpsItemDataValue {
         151  +
        crate::types::OpsItemDataValue {
         152  +
            value: self.value,
         153  +
            r#type: self.r#type,
         154  +
        }
         155  +
    }
         156  +
}

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

@@ -0,1 +0,238 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Describes a filter for a specific list of OpsItem events. You can filter event information by using tags. You specify tags by using a key-value pair mapping.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct OpsItemEventFilter {
           7  +
    /// <p>The name of the filter key. Currently, the only supported value is <code>OpsItemId</code>.</p>
           8  +
    pub key: crate::types::OpsItemEventFilterKey,
           9  +
    /// <p>The values for the filter, consisting of one or more OpsItem IDs.</p>
          10  +
    pub values: ::std::vec::Vec<::std::string::String>,
          11  +
    /// <p>The operator used by the filter call. Currently, the only supported value is <code>Equal</code>.</p>
          12  +
    pub operator: crate::types::OpsItemEventFilterOperator,
          13  +
}
          14  +
impl OpsItemEventFilter {
          15  +
    /// <p>The name of the filter key. Currently, the only supported value is <code>OpsItemId</code>.</p>
          16  +
    pub fn key(&self) -> &crate::types::OpsItemEventFilterKey {
          17  +
        &self.key
          18  +
    }
          19  +
    /// <p>The values for the filter, consisting of one or more OpsItem IDs.</p>
          20  +
    pub fn values(&self) -> &[::std::string::String] {
          21  +
        use std::ops::Deref;
          22  +
        self.values.deref()
          23  +
    }
          24  +
    /// <p>The operator used by the filter call. Currently, the only supported value is <code>Equal</code>.</p>
          25  +
    pub fn operator(&self) -> &crate::types::OpsItemEventFilterOperator {
          26  +
        &self.operator
          27  +
    }
          28  +
}
          29  +
static OPSITEMEVENTFILTER_MEMBER_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          30  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemEventFilter$Key", "com.amazonaws.ssm", "OpsItemEventFilter"),
          31  +
    ::aws_smithy_schema::ShapeType::String,
          32  +
    "Key",
          33  +
    0,
          34  +
);
          35  +
static OPSITEMEVENTFILTER_MEMBER_VALUES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          36  +
    ::aws_smithy_schema::ShapeId::from_parts(
          37  +
        "com.amazonaws.ssm#OpsItemEventFilterValues$member",
          38  +
        "com.amazonaws.ssm",
          39  +
        "OpsItemEventFilterValues",
          40  +
    ),
          41  +
    ::aws_smithy_schema::ShapeType::String,
          42  +
    "member",
          43  +
    0,
          44  +
);
          45  +
static OPSITEMEVENTFILTER_MEMBER_VALUES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          46  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemEventFilter$Values", "com.amazonaws.ssm", "OpsItemEventFilter"),
          47  +
    ::aws_smithy_schema::ShapeType::List,
          48  +
    "Values",
          49  +
    1,
          50  +
)
          51  +
.with_list_member(&OPSITEMEVENTFILTER_MEMBER_VALUES_MEMBER);
          52  +
static OPSITEMEVENTFILTER_MEMBER_OPERATOR: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          53  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemEventFilter$Operator", "com.amazonaws.ssm", "OpsItemEventFilter"),
          54  +
    ::aws_smithy_schema::ShapeType::String,
          55  +
    "Operator",
          56  +
    2,
          57  +
);
          58  +
static OPSITEMEVENTFILTER_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          59  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemEventFilter", "com.amazonaws.ssm", "OpsItemEventFilter"),
          60  +
    ::aws_smithy_schema::ShapeType::Structure,
          61  +
    &[
          62  +
        &OPSITEMEVENTFILTER_MEMBER_KEY,
          63  +
        &OPSITEMEVENTFILTER_MEMBER_VALUES,
          64  +
        &OPSITEMEVENTFILTER_MEMBER_OPERATOR,
          65  +
    ],
          66  +
);
          67  +
impl OpsItemEventFilter {
          68  +
    /// The schema for this shape.
          69  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPSITEMEVENTFILTER_SCHEMA;
          70  +
}
          71  +
impl ::aws_smithy_schema::serde::SerializableStruct for OpsItemEventFilter {
          72  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          73  +
    fn serialize_members(
          74  +
        &self,
          75  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          76  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          77  +
        {
          78  +
            let val = &self.key;
          79  +
            ser.write_string(&OPSITEMEVENTFILTER_MEMBER_KEY, val.as_str())?;
          80  +
        }
          81  +
        {
          82  +
            let val = &self.values;
          83  +
          84  +
            ser.write_list(
          85  +
                &OPSITEMEVENTFILTER_MEMBER_VALUES,
          86  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
          87  +
                    for item in val {
          88  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
          89  +
                    }
          90  +
                    Ok(())
          91  +
                },
          92  +
            )?;
          93  +
        }
          94  +
        {
          95  +
            let val = &self.operator;
          96  +
            ser.write_string(&OPSITEMEVENTFILTER_MEMBER_OPERATOR, val.as_str())?;
          97  +
        }
          98  +
        Ok(())
          99  +
    }
         100  +
}
         101  +
impl OpsItemEventFilter {
         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(&OPSITEMEVENTFILTER_SCHEMA, &mut |member, deser| {
         116  +
            match member.member_index() {
         117  +
                Some(0) => {
         118  +
                    builder.key = Some(crate::types::OpsItemEventFilterKey::from(deser.read_string(member)?.as_str()));
         119  +
                }
         120  +
                Some(1) => {
         121  +
                    builder.values = Some(deser.read_string_list(member)?);
         122  +
                }
         123  +
                Some(2) => {
         124  +
                    builder.operator = Some(crate::types::OpsItemEventFilterOperator::from(deser.read_string(member)?.as_str()));
         125  +
                }
         126  +
                _ => {}
         127  +
            }
         128  +
            Ok(())
         129  +
        })?;
         130  +
        builder.values = builder.values.or(Some(Vec::new()));
         131  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
         132  +
    }
         133  +
}
         134  +
impl OpsItemEventFilter {
         135  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        Self::deserialize(deserializer)
         143  +
    }
         144  +
}
         145  +
impl OpsItemEventFilter {
         146  +
    /// Creates a new builder-style object to manufacture [`OpsItemEventFilter`](crate::types::OpsItemEventFilter).
         147  +
    pub fn builder() -> crate::types::builders::OpsItemEventFilterBuilder {
         148  +
        crate::types::builders::OpsItemEventFilterBuilder::default()
         149  +
    }
         150  +
}
         151  +
         152  +
/// A builder for [`OpsItemEventFilter`](crate::types::OpsItemEventFilter).
         153  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         154  +
#[non_exhaustive]
         155  +
pub struct OpsItemEventFilterBuilder {
         156  +
    pub(crate) key: ::std::option::Option<crate::types::OpsItemEventFilterKey>,
         157  +
    pub(crate) values: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         158  +
    pub(crate) operator: ::std::option::Option<crate::types::OpsItemEventFilterOperator>,
         159  +
}
         160  +
impl OpsItemEventFilterBuilder {
         161  +
    /// <p>The name of the filter key. Currently, the only supported value is <code>OpsItemId</code>.</p>
         162  +
    /// This field is required.
         163  +
    pub fn key(mut self, input: crate::types::OpsItemEventFilterKey) -> Self {
         164  +
        self.key = ::std::option::Option::Some(input);
         165  +
        self
         166  +
    }
         167  +
    /// <p>The name of the filter key. Currently, the only supported value is <code>OpsItemId</code>.</p>
         168  +
    pub fn set_key(mut self, input: ::std::option::Option<crate::types::OpsItemEventFilterKey>) -> Self {
         169  +
        self.key = input;
         170  +
        self
         171  +
    }
         172  +
    /// <p>The name of the filter key. Currently, the only supported value is <code>OpsItemId</code>.</p>
         173  +
    pub fn get_key(&self) -> &::std::option::Option<crate::types::OpsItemEventFilterKey> {
         174  +
        &self.key
         175  +
    }
         176  +
    /// Appends an item to `values`.
         177  +
    ///
         178  +
    /// To override the contents of this collection use [`set_values`](Self::set_values).
         179  +
    ///
         180  +
    /// <p>The values for the filter, consisting of one or more OpsItem IDs.</p>
         181  +
    pub fn values(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         182  +
        let mut v = self.values.unwrap_or_default();
         183  +
        v.push(input.into());
         184  +
        self.values = ::std::option::Option::Some(v);
         185  +
        self
         186  +
    }
         187  +
    /// <p>The values for the filter, consisting of one or more OpsItem IDs.</p>
         188  +
    pub fn set_values(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         189  +
        self.values = input;
         190  +
        self
         191  +
    }
         192  +
    /// <p>The values for the filter, consisting of one or more OpsItem IDs.</p>
         193  +
    pub fn get_values(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         194  +
        &self.values
         195  +
    }
         196  +
    /// <p>The operator used by the filter call. Currently, the only supported value is <code>Equal</code>.</p>
         197  +
    /// This field is required.
         198  +
    pub fn operator(mut self, input: crate::types::OpsItemEventFilterOperator) -> Self {
         199  +
        self.operator = ::std::option::Option::Some(input);
         200  +
        self
         201  +
    }
         202  +
    /// <p>The operator used by the filter call. Currently, the only supported value is <code>Equal</code>.</p>
         203  +
    pub fn set_operator(mut self, input: ::std::option::Option<crate::types::OpsItemEventFilterOperator>) -> Self {
         204  +
        self.operator = input;
         205  +
        self
         206  +
    }
         207  +
    /// <p>The operator used by the filter call. Currently, the only supported value is <code>Equal</code>.</p>
         208  +
    pub fn get_operator(&self) -> &::std::option::Option<crate::types::OpsItemEventFilterOperator> {
         209  +
        &self.operator
         210  +
    }
         211  +
    /// Consumes the builder and constructs a [`OpsItemEventFilter`](crate::types::OpsItemEventFilter).
         212  +
    /// This method will fail if any of the following fields are not set:
         213  +
    /// - [`key`](crate::types::builders::OpsItemEventFilterBuilder::key)
         214  +
    /// - [`values`](crate::types::builders::OpsItemEventFilterBuilder::values)
         215  +
    /// - [`operator`](crate::types::builders::OpsItemEventFilterBuilder::operator)
         216  +
    pub fn build(self) -> ::std::result::Result<crate::types::OpsItemEventFilter, ::aws_smithy_types::error::operation::BuildError> {
         217  +
        ::std::result::Result::Ok(crate::types::OpsItemEventFilter {
         218  +
            key: self.key.ok_or_else(|| {
         219  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
         220  +
                    "key",
         221  +
                    "key was not specified but it is required when building OpsItemEventFilter",
         222  +
                )
         223  +
            })?,
         224  +
            values: self.values.ok_or_else(|| {
         225  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
         226  +
                    "values",
         227  +
                    "values was not specified but it is required when building OpsItemEventFilter",
         228  +
                )
         229  +
            })?,
         230  +
            operator: self.operator.ok_or_else(|| {
         231  +
                ::aws_smithy_types::error::operation::BuildError::missing_field(
         232  +
                    "operator",
         233  +
                    "operator was not specified but it is required when building OpsItemEventFilter",
         234  +
                )
         235  +
            })?,
         236  +
        })
         237  +
    }
         238  +
}

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

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

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

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

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

@@ -0,1 +0,374 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>Summary information about an OpsItem event or that associated an OpsItem with a related item.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct OpsItemEventSummary {
           7  +
    /// <p>The ID of the OpsItem.</p>
           8  +
    pub ops_item_id: ::std::option::Option<::std::string::String>,
           9  +
    /// <p>The ID of the OpsItem event.</p>
          10  +
    pub event_id: ::std::option::Option<::std::string::String>,
          11  +
    /// <p>The source of the OpsItem event.</p>
          12  +
    pub source: ::std::option::Option<::std::string::String>,
          13  +
    /// <p>The type of information provided as a detail.</p>
          14  +
    pub detail_type: ::std::option::Option<::std::string::String>,
          15  +
    /// <p>Specific information about the OpsItem event.</p>
          16  +
    pub detail: ::std::option::Option<::std::string::String>,
          17  +
    /// <p>Information about the user or resource that created the OpsItem event.</p>
          18  +
    pub created_by: ::std::option::Option<crate::types::OpsItemIdentity>,
          19  +
    /// <p>The date and time the OpsItem event was created.</p>
          20  +
    pub created_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          21  +
}
          22  +
impl OpsItemEventSummary {
          23  +
    /// <p>The ID of the OpsItem.</p>
          24  +
    pub fn ops_item_id(&self) -> ::std::option::Option<&str> {
          25  +
        self.ops_item_id.as_deref()
          26  +
    }
          27  +
    /// <p>The ID of the OpsItem event.</p>
          28  +
    pub fn event_id(&self) -> ::std::option::Option<&str> {
          29  +
        self.event_id.as_deref()
          30  +
    }
          31  +
    /// <p>The source of the OpsItem event.</p>
          32  +
    pub fn source(&self) -> ::std::option::Option<&str> {
          33  +
        self.source.as_deref()
          34  +
    }
          35  +
    /// <p>The type of information provided as a detail.</p>
          36  +
    pub fn detail_type(&self) -> ::std::option::Option<&str> {
          37  +
        self.detail_type.as_deref()
          38  +
    }
          39  +
    /// <p>Specific information about the OpsItem event.</p>
          40  +
    pub fn detail(&self) -> ::std::option::Option<&str> {
          41  +
        self.detail.as_deref()
          42  +
    }
          43  +
    /// <p>Information about the user or resource that created the OpsItem event.</p>
          44  +
    pub fn created_by(&self) -> ::std::option::Option<&crate::types::OpsItemIdentity> {
          45  +
        self.created_by.as_ref()
          46  +
    }
          47  +
    /// <p>The date and time the OpsItem event was created.</p>
          48  +
    pub fn created_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          49  +
        self.created_time.as_ref()
          50  +
    }
          51  +
}
          52  +
static OPSITEMEVENTSUMMARY_MEMBER_OPS_ITEM_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          53  +
    ::aws_smithy_schema::ShapeId::from_parts(
          54  +
        "com.amazonaws.ssm#OpsItemEventSummary$OpsItemId",
          55  +
        "com.amazonaws.ssm",
          56  +
        "OpsItemEventSummary",
          57  +
    ),
          58  +
    ::aws_smithy_schema::ShapeType::String,
          59  +
    "OpsItemId",
          60  +
    0,
          61  +
);
          62  +
static OPSITEMEVENTSUMMARY_MEMBER_EVENT_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          63  +
    ::aws_smithy_schema::ShapeId::from_parts(
          64  +
        "com.amazonaws.ssm#OpsItemEventSummary$EventId",
          65  +
        "com.amazonaws.ssm",
          66  +
        "OpsItemEventSummary",
          67  +
    ),
          68  +
    ::aws_smithy_schema::ShapeType::String,
          69  +
    "EventId",
          70  +
    1,
          71  +
);
          72  +
static OPSITEMEVENTSUMMARY_MEMBER_SOURCE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          73  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemEventSummary$Source", "com.amazonaws.ssm", "OpsItemEventSummary"),
          74  +
    ::aws_smithy_schema::ShapeType::String,
          75  +
    "Source",
          76  +
    2,
          77  +
);
          78  +
static OPSITEMEVENTSUMMARY_MEMBER_DETAIL_TYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          79  +
    ::aws_smithy_schema::ShapeId::from_parts(
          80  +
        "com.amazonaws.ssm#OpsItemEventSummary$DetailType",
          81  +
        "com.amazonaws.ssm",
          82  +
        "OpsItemEventSummary",
          83  +
    ),
          84  +
    ::aws_smithy_schema::ShapeType::String,
          85  +
    "DetailType",
          86  +
    3,
          87  +
);
          88  +
static OPSITEMEVENTSUMMARY_MEMBER_DETAIL: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          89  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemEventSummary$Detail", "com.amazonaws.ssm", "OpsItemEventSummary"),
          90  +
    ::aws_smithy_schema::ShapeType::String,
          91  +
    "Detail",
          92  +
    4,
          93  +
);
          94  +
static OPSITEMEVENTSUMMARY_MEMBER_CREATED_BY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          95  +
    ::aws_smithy_schema::ShapeId::from_parts(
          96  +
        "com.amazonaws.ssm#OpsItemEventSummary$CreatedBy",
          97  +
        "com.amazonaws.ssm",
          98  +
        "OpsItemEventSummary",
          99  +
    ),
         100  +
    ::aws_smithy_schema::ShapeType::Structure,
         101  +
    "CreatedBy",
         102  +
    5,
         103  +
);
         104  +
static OPSITEMEVENTSUMMARY_MEMBER_CREATED_TIME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         105  +
    ::aws_smithy_schema::ShapeId::from_parts(
         106  +
        "com.amazonaws.ssm#OpsItemEventSummary$CreatedTime",
         107  +
        "com.amazonaws.ssm",
         108  +
        "OpsItemEventSummary",
         109  +
    ),
         110  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         111  +
    "CreatedTime",
         112  +
    6,
         113  +
);
         114  +
static OPSITEMEVENTSUMMARY_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         115  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#OpsItemEventSummary", "com.amazonaws.ssm", "OpsItemEventSummary"),
         116  +
    ::aws_smithy_schema::ShapeType::Structure,
         117  +
    &[
         118  +
        &OPSITEMEVENTSUMMARY_MEMBER_OPS_ITEM_ID,
         119  +
        &OPSITEMEVENTSUMMARY_MEMBER_EVENT_ID,
         120  +
        &OPSITEMEVENTSUMMARY_MEMBER_SOURCE,
         121  +
        &OPSITEMEVENTSUMMARY_MEMBER_DETAIL_TYPE,
         122  +
        &OPSITEMEVENTSUMMARY_MEMBER_DETAIL,
         123  +
        &OPSITEMEVENTSUMMARY_MEMBER_CREATED_BY,
         124  +
        &OPSITEMEVENTSUMMARY_MEMBER_CREATED_TIME,
         125  +
    ],
         126  +
);
         127  +
impl OpsItemEventSummary {
         128  +
    /// The schema for this shape.
         129  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &OPSITEMEVENTSUMMARY_SCHEMA;
         130  +
}
         131  +
impl ::aws_smithy_schema::serde::SerializableStruct for OpsItemEventSummary {
         132  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         133  +
    fn serialize_members(
         134  +
        &self,
         135  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         136  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         137  +
        if let Some(ref val) = self.ops_item_id {
         138  +
            ser.write_string(&OPSITEMEVENTSUMMARY_MEMBER_OPS_ITEM_ID, val)?;
         139  +
        }
         140  +
        if let Some(ref val) = self.event_id {
         141  +
            ser.write_string(&OPSITEMEVENTSUMMARY_MEMBER_EVENT_ID, val)?;
         142  +
        }
         143  +
        if let Some(ref val) = self.source {
         144  +
            ser.write_string(&OPSITEMEVENTSUMMARY_MEMBER_SOURCE, val)?;
         145  +
        }
         146  +
        if let Some(ref val) = self.detail_type {
         147  +
            ser.write_string(&OPSITEMEVENTSUMMARY_MEMBER_DETAIL_TYPE, val)?;
         148  +
        }
         149  +
        if let Some(ref val) = self.detail {
         150  +
            ser.write_string(&OPSITEMEVENTSUMMARY_MEMBER_DETAIL, val)?;
         151  +
        }
         152  +
        if let Some(ref val) = self.created_by {
         153  +
            ser.write_struct(&OPSITEMEVENTSUMMARY_MEMBER_CREATED_BY, val)?;
         154  +
        }
         155  +
        if let Some(ref val) = self.created_time {
         156  +
            ser.write_timestamp(&OPSITEMEVENTSUMMARY_MEMBER_CREATED_TIME, val)?;
         157  +
        }
         158  +
        Ok(())
         159  +
    }
         160  +
}
         161  +
impl OpsItemEventSummary {
         162  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         163  +
    pub fn deserialize(
         164  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         165  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         166  +
        #[allow(unused_variables, unused_mut)]
         167  +
        let mut builder = Self::builder();
         168  +
        #[allow(
         169  +
            unused_variables,
         170  +
            unreachable_code,
         171  +
            clippy::single_match,
         172  +
            clippy::match_single_binding,
         173  +
            clippy::diverging_sub_expression
         174  +
        )]
         175  +
        deserializer.read_struct(&OPSITEMEVENTSUMMARY_SCHEMA, &mut |member, deser| {
         176  +
            match member.member_index() {
         177  +
                Some(0) => {
         178  +
                    if deser.is_null() {
         179  +
                        deser.read_null()?;
         180  +
                    } else {
         181  +
                        builder.ops_item_id = Some(deser.read_string(member)?);
         182  +
                    }
         183  +
                }
         184  +
                Some(1) => {
         185  +
                    if deser.is_null() {
         186  +
                        deser.read_null()?;
         187  +
                    } else {
         188  +
                        builder.event_id = Some(deser.read_string(member)?);
         189  +
                    }
         190  +
                }
         191  +
                Some(2) => {
         192  +
                    if deser.is_null() {
         193  +
                        deser.read_null()?;
         194  +
                    } else {
         195  +
                        builder.source = Some(deser.read_string(member)?);
         196  +
                    }
         197  +
                }
         198  +
                Some(3) => {
         199  +
                    if deser.is_null() {
         200  +
                        deser.read_null()?;
         201  +
                    } else {
         202  +
                        builder.detail_type = Some(deser.read_string(member)?);
         203  +
                    }
         204  +
                }
         205  +
                Some(4) => {
         206  +
                    if deser.is_null() {
         207  +
                        deser.read_null()?;
         208  +
                    } else {
         209  +
                        builder.detail = Some(deser.read_string(member)?);
         210  +
                    }
         211  +
                }
         212  +
                Some(5) => {
         213  +
                    if deser.is_null() {
         214  +
                        deser.read_null()?;
         215  +
                    } else {
         216  +
                        builder.created_by = Some(crate::types::OpsItemIdentity::deserialize(deser)?);
         217  +
                    }
         218  +
                }
         219  +
                Some(6) => {
         220  +
                    if deser.is_null() {
         221  +
                        deser.read_null()?;
         222  +
                    } else {
         223  +
                        builder.created_time = Some(deser.read_timestamp(member)?);
         224  +
                    }
         225  +
                }
         226  +
                _ => {}
         227  +
            }
         228  +
            Ok(())
         229  +
        })?;
         230  +
        Ok(builder.build())
         231  +
    }
         232  +
}
         233  +
impl OpsItemEventSummary {
         234  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         235  +
    pub fn deserialize_with_response(
         236  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         237  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         238  +
        _status: u16,
         239  +
        _body: &[u8],
         240  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         241  +
        Self::deserialize(deserializer)
         242  +
    }
         243  +
}
         244  +
impl OpsItemEventSummary {
         245  +
    /// Creates a new builder-style object to manufacture [`OpsItemEventSummary`](crate::types::OpsItemEventSummary).
         246  +
    pub fn builder() -> crate::types::builders::OpsItemEventSummaryBuilder {
         247  +
        crate::types::builders::OpsItemEventSummaryBuilder::default()
         248  +
    }
         249  +
}
         250  +
         251  +
/// A builder for [`OpsItemEventSummary`](crate::types::OpsItemEventSummary).
         252  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         253  +
#[non_exhaustive]
         254  +
pub struct OpsItemEventSummaryBuilder {
         255  +
    pub(crate) ops_item_id: ::std::option::Option<::std::string::String>,
         256  +
    pub(crate) event_id: ::std::option::Option<::std::string::String>,
         257  +
    pub(crate) source: ::std::option::Option<::std::string::String>,
         258  +
    pub(crate) detail_type: ::std::option::Option<::std::string::String>,
         259  +
    pub(crate) detail: ::std::option::Option<::std::string::String>,
         260  +
    pub(crate) created_by: ::std::option::Option<crate::types::OpsItemIdentity>,
         261  +
    pub(crate) created_time: ::std::option::Option<::aws_smithy_types::DateTime>,
         262  +
}
         263  +
impl OpsItemEventSummaryBuilder {
         264  +
    /// <p>The ID of the OpsItem.</p>
         265  +
    pub fn ops_item_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         266  +
        self.ops_item_id = ::std::option::Option::Some(input.into());
         267  +
        self
         268  +
    }
         269  +
    /// <p>The ID of the OpsItem.</p>
         270  +
    pub fn set_ops_item_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         271  +
        self.ops_item_id = input;
         272  +
        self
         273  +
    }
         274  +
    /// <p>The ID of the OpsItem.</p>
         275  +
    pub fn get_ops_item_id(&self) -> &::std::option::Option<::std::string::String> {
         276  +
        &self.ops_item_id
         277  +
    }
         278  +
    /// <p>The ID of the OpsItem event.</p>
         279  +
    pub fn event_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         280  +
        self.event_id = ::std::option::Option::Some(input.into());
         281  +
        self
         282  +
    }
         283  +
    /// <p>The ID of the OpsItem event.</p>
         284  +
    pub fn set_event_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         285  +
        self.event_id = input;
         286  +
        self
         287  +
    }
         288  +
    /// <p>The ID of the OpsItem event.</p>
         289  +
    pub fn get_event_id(&self) -> &::std::option::Option<::std::string::String> {
         290  +
        &self.event_id
         291  +
    }
         292  +
    /// <p>The source of the OpsItem event.</p>
         293  +
    pub fn source(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         294  +
        self.source = ::std::option::Option::Some(input.into());
         295  +
        self
         296  +
    }
         297  +
    /// <p>The source of the OpsItem event.</p>
         298  +
    pub fn set_source(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         299  +
        self.source = input;
         300  +
        self
         301  +
    }
         302  +
    /// <p>The source of the OpsItem event.</p>
         303  +
    pub fn get_source(&self) -> &::std::option::Option<::std::string::String> {
         304  +
        &self.source
         305  +
    }
         306  +
    /// <p>The type of information provided as a detail.</p>
         307  +
    pub fn detail_type(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         308  +
        self.detail_type = ::std::option::Option::Some(input.into());
         309  +
        self
         310  +
    }
         311  +
    /// <p>The type of information provided as a detail.</p>
         312  +
    pub fn set_detail_type(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         313  +
        self.detail_type = input;
         314  +
        self
         315  +
    }
         316  +
    /// <p>The type of information provided as a detail.</p>
         317  +
    pub fn get_detail_type(&self) -> &::std::option::Option<::std::string::String> {
         318  +
        &self.detail_type
         319  +
    }
         320  +
    /// <p>Specific information about the OpsItem event.</p>
         321  +
    pub fn detail(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         322  +
        self.detail = ::std::option::Option::Some(input.into());
         323  +
        self
         324  +
    }
         325  +
    /// <p>Specific information about the OpsItem event.</p>
         326  +
    pub fn set_detail(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         327  +
        self.detail = input;
         328  +
        self
         329  +
    }
         330  +
    /// <p>Specific information about the OpsItem event.</p>
         331  +
    pub fn get_detail(&self) -> &::std::option::Option<::std::string::String> {
         332  +
        &self.detail
         333  +
    }
         334  +
    /// <p>Information about the user or resource that created the OpsItem event.</p>
         335  +
    pub fn created_by(mut self, input: crate::types::OpsItemIdentity) -> Self {
         336  +
        self.created_by = ::std::option::Option::Some(input);
         337  +
        self
         338  +
    }
         339  +
    /// <p>Information about the user or resource that created the OpsItem event.</p>
         340  +
    pub fn set_created_by(mut self, input: ::std::option::Option<crate::types::OpsItemIdentity>) -> Self {
         341  +
        self.created_by = input;
         342  +
        self
         343  +
    }
         344  +
    /// <p>Information about the user or resource that created the OpsItem event.</p>
         345  +
    pub fn get_created_by(&self) -> &::std::option::Option<crate::types::OpsItemIdentity> {
         346  +
        &self.created_by
         347  +
    }
         348  +
    /// <p>The date and time the OpsItem event was created.</p>
         349  +
    pub fn created_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         350  +
        self.created_time = ::std::option::Option::Some(input);
         351  +
        self
         352  +
    }
         353  +
    /// <p>The date and time the OpsItem event was created.</p>
         354  +
    pub fn set_created_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         355  +
        self.created_time = input;
         356  +
        self
         357  +
    }
         358  +
    /// <p>The date and time the OpsItem event was created.</p>
         359  +
    pub fn get_created_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         360  +
        &self.created_time
         361  +
    }
         362  +
    /// Consumes the builder and constructs a [`OpsItemEventSummary`](crate::types::OpsItemEventSummary).
         363  +
    pub fn build(self) -> crate::types::OpsItemEventSummary {
         364  +
        crate::types::OpsItemEventSummary {
         365  +
            ops_item_id: self.ops_item_id,
         366  +
            event_id: self.event_id,
         367  +
            source: self.source,
         368  +
            detail_type: self.detail_type,
         369  +
            detail: self.detail,
         370  +
            created_by: self.created_by,
         371  +
            created_time: self.created_time,
         372  +
        }
         373  +
    }
         374  +
}