AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_rename_key_entry.rs

@@ -22,22 +162,175 @@
   42     42   
    "key",
   43     43   
    0,
   44     44   
);
   45     45   
static RENAMEKEYENTRY_MEMBER_RENAME_TO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.cloudwatchlogs#RenameKeyEntry$renameTo",
   48     48   
        "com.amazonaws.cloudwatchlogs",
   49     49   
        "RenameKeyEntry",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "rename_to",
          52  +
    "renameTo",
   53     53   
    1,
   54     54   
);
   55     55   
static RENAMEKEYENTRY_MEMBER_OVERWRITE_IF_EXISTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.cloudwatchlogs#RenameKeyEntry$overwriteIfExists",
   58     58   
        "com.amazonaws.cloudwatchlogs",
   59     59   
        "RenameKeyEntry",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Boolean,
   62         -
    "overwrite_if_exists",
          62  +
    "overwriteIfExists",
   63     63   
    2,
   64     64   
);
   65     65   
static RENAMEKEYENTRY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    RENAMEKEYENTRY_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &RENAMEKEYENTRY_MEMBER_KEY,
   70     70   
        &RENAMEKEYENTRY_MEMBER_RENAME_TO,
   71     71   
        &RENAMEKEYENTRY_MEMBER_OVERWRITE_IF_EXISTS,
   72     72   
    ],
   73     73   
);
   74     74   
impl RenameKeyEntry {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RENAMEKEYENTRY_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for RenameKeyEntry {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        {
   85     85   
            let val = &self.key;
   86     86   
            ser.write_string(&RENAMEKEYENTRY_MEMBER_KEY, val)?;
   87     87   
        }
   88     88   
        {
   89     89   
            let val = &self.rename_to;
   90     90   
            ser.write_string(&RENAMEKEYENTRY_MEMBER_RENAME_TO, val)?;
   91     91   
        }
   92     92   
        {
   93     93   
            let val = &self.overwrite_if_exists;
   94     94   
            ser.write_boolean(&RENAMEKEYENTRY_MEMBER_OVERWRITE_IF_EXISTS, *val)?;
   95     95   
        }
   96     96   
        Ok(())
   97     97   
    }
   98     98   
}
   99     99   
impl RenameKeyEntry {
  100    100   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  101         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  102         -
        deserializer: &mut D,
         101  +
    pub fn deserialize(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  103    103   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        #[allow(unused_variables, unused_mut)]
  105    105   
        let mut builder = Self::builder();
  106    106   
        #[allow(
  107    107   
            unused_variables,
  108    108   
            unreachable_code,
  109    109   
            clippy::single_match,
  110    110   
            clippy::match_single_binding,
  111    111   
            clippy::diverging_sub_expression
  112    112   
        )]
  113         -
        deserializer.read_struct(&RENAMEKEYENTRY_SCHEMA, (), |_, member, deser| {
         113  +
        deserializer.read_struct(&RENAMEKEYENTRY_SCHEMA, &mut |member, deser| {
  114    114   
            match member.member_index() {
  115    115   
                Some(0) => {
  116    116   
                    builder.key = Some(deser.read_string(member)?);
  117    117   
                }
  118    118   
                Some(1) => {
  119    119   
                    builder.rename_to = Some(deser.read_string(member)?);
  120    120   
                }
  121    121   
                Some(2) => {
  122    122   
                    builder.overwrite_if_exists = Some(deser.read_boolean(member)?);
  123    123   
                }
  124    124   
                _ => {}
  125    125   
            }
  126    126   
            Ok(())
  127    127   
        })?;
         128  +
        builder.key = builder.key.or(Some(String::new()));
         129  +
        builder.rename_to = builder.rename_to.or(Some(String::new()));
  128    130   
        builder
  129    131   
            .build()
  130    132   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  131    133   
    }
  132    134   
}
         135  +
impl RenameKeyEntry {
         136  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         137  +
    pub fn deserialize_with_response(
         138  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         139  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         140  +
        _status: u16,
         141  +
        _body: &[u8],
         142  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         143  +
        Self::deserialize(deserializer)
         144  +
    }
         145  +
}
  133    146   
impl RenameKeyEntry {
  134    147   
    /// Creates a new builder-style object to manufacture [`RenameKeyEntry`](crate::types::RenameKeyEntry).
  135    148   
    pub fn builder() -> crate::types::builders::RenameKeyEntryBuilder {
  136    149   
        crate::types::builders::RenameKeyEntryBuilder::default()
  137    150   
    }
  138    151   
}
  139    152   
  140    153   
/// A builder for [`RenameKeyEntry`](crate::types::RenameKeyEntry).
  141    154   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  142    155   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_rename_keys.rs

@@ -33,33 +128,137 @@
   53     53   
                    }
   54     54   
                    Ok(())
   55     55   
                },
   56     56   
            )?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl RenameKeys {
   62     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   63         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   64         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   65     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        #[allow(unused_variables, unused_mut)]
   67     67   
        let mut builder = Self::builder();
   68     68   
        #[allow(
   69     69   
            unused_variables,
   70     70   
            unreachable_code,
   71     71   
            clippy::single_match,
   72     72   
            clippy::match_single_binding,
   73     73   
            clippy::diverging_sub_expression
   74     74   
        )]
   75         -
        deserializer.read_struct(&RENAMEKEYS_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&RENAMEKEYS_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78     78   
                    builder.entries = Some({
   79         -
                        let container = if let Some(cap) = deser.container_size() {
   80         -
                            Vec::with_capacity(cap)
   81         -
                        } else {
   82         -
                            Vec::new()
   83         -
                        };
   84         -
                        deser.read_list(member, container, |mut list, deser| {
   85         -
                            list.push(crate::types::RenameKeyEntry::deserialize(deser)?);
   86         -
                            Ok(list)
   87         -
                        })?
          79  +
                        let mut container = Vec::new();
          80  +
                        deser.read_list(member, &mut |deser| {
          81  +
                            container.push(crate::types::RenameKeyEntry::deserialize(deser)?);
          82  +
                            Ok(())
          83  +
                        })?;
          84  +
                        container
   88     85   
                    });
   89     86   
                }
   90     87   
                _ => {}
   91     88   
            }
   92     89   
            Ok(())
   93     90   
        })?;
          91  +
        builder.entries = builder.entries.or(Some(Vec::new()));
   94     92   
        builder
   95     93   
            .build()
   96     94   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   97     95   
    }
   98     96   
}
          97  +
impl RenameKeys {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   99    108   
impl RenameKeys {
  100    109   
    /// Creates a new builder-style object to manufacture [`RenameKeys`](crate::types::RenameKeys).
  101    110   
    pub fn builder() -> crate::types::builders::RenameKeysBuilder {
  102    111   
        crate::types::builders::RenameKeysBuilder::default()
  103    112   
    }
  104    113   
}
  105    114   
  106    115   
/// A builder for [`RenameKeys`](crate::types::RenameKeys).
  107    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  108    117   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_resource_config.rs

@@ -9,9 +0,94 @@
   29     29   
    }
   30     30   
    /// Returns true if this is a [`OpenSearchResourceConfig`](crate::types::ResourceConfig::OpenSearchResourceConfig).
   31     31   
    pub fn is_open_search_resource_config(&self) -> bool {
   32     32   
        self.as_open_search_resource_config().is_ok()
   33     33   
    }
   34     34   
    /// Returns true if the enum instance is the `Unknown` variant.
   35     35   
    pub fn is_unknown(&self) -> bool {
   36     36   
        matches!(self, Self::Unknown)
   37     37   
    }
   38     38   
}
          39  +
static RESOURCECONFIG_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          40  +
    "com.amazonaws.cloudwatchlogs#ResourceConfig",
          41  +
    "com.amazonaws.cloudwatchlogs",
          42  +
    "ResourceConfig",
          43  +
);
          44  +
static RESOURCECONFIG_MEMBER_OPENSEARCHRESOURCECONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          45  +
    ::aws_smithy_schema::ShapeId::from_static(
          46  +
        "com.amazonaws.cloudwatchlogs#ResourceConfig$openSearchResourceConfig",
          47  +
        "com.amazonaws.cloudwatchlogs",
          48  +
        "ResourceConfig",
          49  +
    ),
          50  +
    ::aws_smithy_schema::ShapeType::Structure,
          51  +
    "openSearchResourceConfig",
          52  +
    0,
          53  +
);
          54  +
static RESOURCECONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          55  +
    RESOURCECONFIG_SCHEMA_ID,
          56  +
    ::aws_smithy_schema::ShapeType::Union,
          57  +
    &[&RESOURCECONFIG_MEMBER_OPENSEARCHRESOURCECONFIG],
          58  +
);
          59  +
impl ResourceConfig {
          60  +
    /// The schema for this shape.
          61  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCECONFIG_SCHEMA;
          62  +
}
          63  +
impl ::aws_smithy_schema::serde::SerializableStruct for ResourceConfig {
          64  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          65  +
    fn serialize_members(
          66  +
        &self,
          67  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          68  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          69  +
        match self {
          70  +
            Self::OpenSearchResourceConfig(val) => {
          71  +
                ser.write_struct(&RESOURCECONFIG_MEMBER_OPENSEARCHRESOURCECONFIG, val)?;
          72  +
            }
          73  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
          74  +
        }
          75  +
        Ok(())
          76  +
    }
          77  +
}
          78  +
impl ResourceConfig {
          79  +
    /// Deserializes this union from a [`ShapeDeserializer`].
          80  +
    pub fn deserialize(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          83  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
          84  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
          85  +
        deserializer.read_struct(&RESOURCECONFIG_SCHEMA, &mut |member, deser| {
          86  +
            result = ::std::option::Option::Some(match member.member_index() {
          87  +
                Some(0) => Self::OpenSearchResourceConfig(crate::types::OpenSearchResourceConfig::deserialize(deser)?),
          88  +
                _ => Self::Unknown,
          89  +
            });
          90  +
            Ok(())
          91  +
        })?;
          92  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
          93  +
    }
          94  +
}

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_resource_policy.rs

@@ -28,28 +224,235 @@
   48     48   
    "com.amazonaws.cloudwatchlogs",
   49     49   
    "ResourcePolicy",
   50     50   
);
   51     51   
static RESOURCEPOLICY_MEMBER_POLICY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.cloudwatchlogs#ResourcePolicy$policyName",
   54     54   
        "com.amazonaws.cloudwatchlogs",
   55     55   
        "ResourcePolicy",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "policy_name",
          58  +
    "policyName",
   59     59   
    0,
   60     60   
);
   61     61   
static RESOURCEPOLICY_MEMBER_POLICY_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.cloudwatchlogs#ResourcePolicy$policyDocument",
   64     64   
        "com.amazonaws.cloudwatchlogs",
   65     65   
        "ResourcePolicy",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "policy_document",
          68  +
    "policyDocument",
   69     69   
    1,
   70     70   
);
   71     71   
static RESOURCEPOLICY_MEMBER_LAST_UPDATED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.cloudwatchlogs#ResourcePolicy$lastUpdatedTime",
   74     74   
        "com.amazonaws.cloudwatchlogs",
   75     75   
        "ResourcePolicy",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::Long,
   78         -
    "last_updated_time",
          78  +
    "lastUpdatedTime",
   79     79   
    2,
   80     80   
);
   81     81   
static RESOURCEPOLICY_MEMBER_POLICY_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.cloudwatchlogs#ResourcePolicy$policyScope",
   84     84   
        "com.amazonaws.cloudwatchlogs",
   85     85   
        "ResourcePolicy",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "policy_scope",
          88  +
    "policyScope",
   89     89   
    3,
   90     90   
);
   91     91   
static RESOURCEPOLICY_MEMBER_RESOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.cloudwatchlogs#ResourcePolicy$resourceArn",
   94     94   
        "com.amazonaws.cloudwatchlogs",
   95     95   
        "ResourcePolicy",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "resource_arn",
          98  +
    "resourceArn",
   99     99   
    4,
  100    100   
);
  101    101   
static RESOURCEPOLICY_MEMBER_REVISION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.cloudwatchlogs#ResourcePolicy$revisionId",
  104    104   
        "com.amazonaws.cloudwatchlogs",
  105    105   
        "ResourcePolicy",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "revision_id",
         108  +
    "revisionId",
  109    109   
    5,
  110    110   
);
  111    111   
static RESOURCEPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  112    112   
    RESOURCEPOLICY_SCHEMA_ID,
  113    113   
    ::aws_smithy_schema::ShapeType::Structure,
  114    114   
    &[
  115    115   
        &RESOURCEPOLICY_MEMBER_POLICY_NAME,
  116    116   
        &RESOURCEPOLICY_MEMBER_POLICY_DOCUMENT,
  117    117   
        &RESOURCEPOLICY_MEMBER_LAST_UPDATED_TIME,
  118    118   
        &RESOURCEPOLICY_MEMBER_POLICY_SCOPE,
  119    119   
        &RESOURCEPOLICY_MEMBER_RESOURCE_ARN,
  120    120   
        &RESOURCEPOLICY_MEMBER_REVISION_ID,
  121    121   
    ],
  122    122   
);
  123    123   
impl ResourcePolicy {
  124    124   
    /// The schema for this shape.
  125    125   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCEPOLICY_SCHEMA;
  126    126   
}
  127    127   
impl ::aws_smithy_schema::serde::SerializableStruct for ResourcePolicy {
  128    128   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  129    129   
    fn serialize_members(
  130    130   
        &self,
  131    131   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  132    132   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  133    133   
        if let Some(ref val) = self.policy_name {
  134    134   
            ser.write_string(&RESOURCEPOLICY_MEMBER_POLICY_NAME, val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.policy_document {
  137    137   
            ser.write_string(&RESOURCEPOLICY_MEMBER_POLICY_DOCUMENT, val)?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.last_updated_time {
  140    140   
            ser.write_long(&RESOURCEPOLICY_MEMBER_LAST_UPDATED_TIME, *val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.policy_scope {
  143    143   
            ser.write_string(&RESOURCEPOLICY_MEMBER_POLICY_SCOPE, val.as_str())?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.resource_arn {
  146    146   
            ser.write_string(&RESOURCEPOLICY_MEMBER_RESOURCE_ARN, val)?;
  147    147   
        }
  148    148   
        if let Some(ref val) = self.revision_id {
  149    149   
            ser.write_string(&RESOURCEPOLICY_MEMBER_REVISION_ID, val)?;
  150    150   
        }
  151    151   
        Ok(())
  152    152   
    }
  153    153   
}
  154    154   
impl ResourcePolicy {
  155    155   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  156         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  157         -
        deserializer: &mut D,
         156  +
    pub fn deserialize(
         157  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  158    158   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  159    159   
        #[allow(unused_variables, unused_mut)]
  160    160   
        let mut builder = Self::builder();
  161    161   
        #[allow(
  162    162   
            unused_variables,
  163    163   
            unreachable_code,
  164    164   
            clippy::single_match,
  165    165   
            clippy::match_single_binding,
  166    166   
            clippy::diverging_sub_expression
  167    167   
        )]
  168         -
        deserializer.read_struct(&RESOURCEPOLICY_SCHEMA, (), |_, member, deser| {
         168  +
        deserializer.read_struct(&RESOURCEPOLICY_SCHEMA, &mut |member, deser| {
  169    169   
            match member.member_index() {
  170    170   
                Some(0) => {
  171    171   
                    builder.policy_name = Some(deser.read_string(member)?);
  172    172   
                }
  173    173   
                Some(1) => {
  174    174   
                    builder.policy_document = Some(deser.read_string(member)?);
  175    175   
                }
  176    176   
                Some(2) => {
  177    177   
                    builder.last_updated_time = Some(deser.read_long(member)?);
  178    178   
                }
  179    179   
                Some(3) => {
  180    180   
                    builder.policy_scope = Some(crate::types::PolicyScope::from(deser.read_string(member)?.as_str()));
  181    181   
                }
  182    182   
                Some(4) => {
  183    183   
                    builder.resource_arn = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                Some(5) => {
  186    186   
                    builder.revision_id = Some(deser.read_string(member)?);
  187    187   
                }
  188    188   
                _ => {}
  189    189   
            }
  190    190   
            Ok(())
  191    191   
        })?;
  192    192   
        Ok(builder.build())
  193    193   
    }
  194    194   
}
         195  +
impl ResourcePolicy {
         196  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         197  +
    pub fn deserialize_with_response(
         198  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         199  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         200  +
        _status: u16,
         201  +
        _body: &[u8],
         202  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         203  +
        Self::deserialize(deserializer)
         204  +
    }
         205  +
}
  195    206   
impl ResourcePolicy {
  196    207   
    /// Creates a new builder-style object to manufacture [`ResourcePolicy`](crate::types::ResourcePolicy).
  197    208   
    pub fn builder() -> crate::types::builders::ResourcePolicyBuilder {
  198    209   
        crate::types::builders::ResourcePolicyBuilder::default()
  199    210   
    }
  200    211   
}
  201    212   
  202    213   
/// A builder for [`ResourcePolicy`](crate::types::ResourcePolicy).
  203    214   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  204    215   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_result_field.rs

@@ -41,41 +127,138 @@
   61     61   
            ser.write_string(&RESULTFIELD_MEMBER_FIELD, val)?;
   62     62   
        }
   63     63   
        if let Some(ref val) = self.value {
   64     64   
            ser.write_string(&RESULTFIELD_MEMBER_VALUE, val)?;
   65     65   
        }
   66     66   
        Ok(())
   67     67   
    }
   68     68   
}
   69     69   
impl ResultField {
   70     70   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   71         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   72         -
        deserializer: &mut D,
          71  +
    pub fn deserialize(
          72  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   73     73   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   74     74   
        #[allow(unused_variables, unused_mut)]
   75     75   
        let mut builder = Self::builder();
   76     76   
        #[allow(
   77     77   
            unused_variables,
   78     78   
            unreachable_code,
   79     79   
            clippy::single_match,
   80     80   
            clippy::match_single_binding,
   81     81   
            clippy::diverging_sub_expression
   82     82   
        )]
   83         -
        deserializer.read_struct(&RESULTFIELD_SCHEMA, (), |_, member, deser| {
          83  +
        deserializer.read_struct(&RESULTFIELD_SCHEMA, &mut |member, deser| {
   84     84   
            match member.member_index() {
   85     85   
                Some(0) => {
   86     86   
                    builder.field = Some(deser.read_string(member)?);
   87     87   
                }
   88     88   
                Some(1) => {
   89     89   
                    builder.value = Some(deser.read_string(member)?);
   90     90   
                }
   91     91   
                _ => {}
   92     92   
            }
   93     93   
            Ok(())
   94     94   
        })?;
   95     95   
        Ok(builder.build())
   96     96   
    }
   97     97   
}
          98  +
impl ResultField {
          99  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         100  +
    pub fn deserialize_with_response(
         101  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         102  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         103  +
        _status: u16,
         104  +
        _body: &[u8],
         105  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         106  +
        Self::deserialize(deserializer)
         107  +
    }
         108  +
}
   98    109   
impl ResultField {
   99    110   
    /// Creates a new builder-style object to manufacture [`ResultField`](crate::types::ResultField).
  100    111   
    pub fn builder() -> crate::types::builders::ResultFieldBuilder {
  101    112   
        crate::types::builders::ResultFieldBuilder::default()
  102    113   
    }
  103    114   
}
  104    115   
  105    116   
/// A builder for [`ResultField`](crate::types::ResultField).
  106    117   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  107    118   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_s3_delivery_configuration.rs

@@ -4,4 +132,143 @@
   24     24   
    "com.amazonaws.cloudwatchlogs",
   25     25   
    "S3DeliveryConfiguration",
   26     26   
);
   27     27   
static S3DELIVERYCONFIGURATION_MEMBER_SUFFIX_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.cloudwatchlogs#S3DeliveryConfiguration$suffixPath",
   30     30   
        "com.amazonaws.cloudwatchlogs",
   31     31   
        "S3DeliveryConfiguration",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "suffix_path",
          34  +
    "suffixPath",
   35     35   
    0,
   36     36   
);
   37     37   
static S3DELIVERYCONFIGURATION_MEMBER_ENABLE_HIVE_COMPATIBLE_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.cloudwatchlogs#S3DeliveryConfiguration$enableHiveCompatiblePath",
   40     40   
        "com.amazonaws.cloudwatchlogs",
   41     41   
        "S3DeliveryConfiguration",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Boolean,
   44         -
    "enable_hive_compatible_path",
          44  +
    "enableHiveCompatiblePath",
   45     45   
    1,
   46     46   
);
   47     47   
static S3DELIVERYCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    S3DELIVERYCONFIGURATION_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &S3DELIVERYCONFIGURATION_MEMBER_SUFFIX_PATH,
   52     52   
        &S3DELIVERYCONFIGURATION_MEMBER_ENABLE_HIVE_COMPATIBLE_PATH,
   53     53   
    ],
   54     54   
);
   55     55   
impl S3DeliveryConfiguration {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &S3DELIVERYCONFIGURATION_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for S3DeliveryConfiguration {
   60     60   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   61     61   
    fn serialize_members(
   62     62   
        &self,
   63     63   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   64     64   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        if let Some(ref val) = self.suffix_path {
   66     66   
            ser.write_string(&S3DELIVERYCONFIGURATION_MEMBER_SUFFIX_PATH, val)?;
   67     67   
        }
   68     68   
        if let Some(ref val) = self.enable_hive_compatible_path {
   69     69   
            ser.write_boolean(&S3DELIVERYCONFIGURATION_MEMBER_ENABLE_HIVE_COMPATIBLE_PATH, *val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl S3DeliveryConfiguration {
   75     75   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   76         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   77         -
        deserializer: &mut D,
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   78     78   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        #[allow(unused_variables, unused_mut)]
   80     80   
        let mut builder = Self::builder();
   81     81   
        #[allow(
   82     82   
            unused_variables,
   83     83   
            unreachable_code,
   84     84   
            clippy::single_match,
   85     85   
            clippy::match_single_binding,
   86     86   
            clippy::diverging_sub_expression
   87     87   
        )]
   88         -
        deserializer.read_struct(&S3DELIVERYCONFIGURATION_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&S3DELIVERYCONFIGURATION_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.suffix_path = Some(deser.read_string(member)?);
   92     92   
                }
   93     93   
                Some(1) => {
   94     94   
                    builder.enable_hive_compatible_path = Some(deser.read_boolean(member)?);
   95     95   
                }
   96     96   
                _ => {}
   97     97   
            }
   98     98   
            Ok(())
   99     99   
        })?;
  100    100   
        Ok(builder.build())
  101    101   
    }
  102    102   
}
         103  +
impl S3DeliveryConfiguration {
         104  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         105  +
    pub fn deserialize_with_response(
         106  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         107  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         108  +
        _status: u16,
         109  +
        _body: &[u8],
         110  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         111  +
        Self::deserialize(deserializer)
         112  +
    }
         113  +
}
  103    114   
impl S3DeliveryConfiguration {
  104    115   
    /// Creates a new builder-style object to manufacture [`S3DeliveryConfiguration`](crate::types::S3DeliveryConfiguration).
  105    116   
    pub fn builder() -> crate::types::builders::S3DeliveryConfigurationBuilder {
  106    117   
        crate::types::builders::S3DeliveryConfigurationBuilder::default()
  107    118   
    }
  108    119   
}
  109    120   
  110    121   
/// A builder for [`S3DeliveryConfiguration`](crate::types::S3DeliveryConfiguration).
  111    122   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  112    123   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_searched_log_stream.rs

@@ -4,4 +129,140 @@
   24     24   
    "com.amazonaws.cloudwatchlogs",
   25     25   
    "SearchedLogStream",
   26     26   
);
   27     27   
static SEARCHEDLOGSTREAM_MEMBER_LOG_STREAM_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.cloudwatchlogs#SearchedLogStream$logStreamName",
   30     30   
        "com.amazonaws.cloudwatchlogs",
   31     31   
        "SearchedLogStream",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "log_stream_name",
          34  +
    "logStreamName",
   35     35   
    0,
   36     36   
);
   37     37   
static SEARCHEDLOGSTREAM_MEMBER_SEARCHED_COMPLETELY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.cloudwatchlogs#SearchedLogStream$searchedCompletely",
   40     40   
        "com.amazonaws.cloudwatchlogs",
   41     41   
        "SearchedLogStream",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Boolean,
   44         -
    "searched_completely",
          44  +
    "searchedCompletely",
   45     45   
    1,
   46     46   
);
   47     47   
static SEARCHEDLOGSTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    SEARCHEDLOGSTREAM_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&SEARCHEDLOGSTREAM_MEMBER_LOG_STREAM_NAME, &SEARCHEDLOGSTREAM_MEMBER_SEARCHED_COMPLETELY],
   51     51   
);
   52     52   
impl SearchedLogStream {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SEARCHEDLOGSTREAM_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for SearchedLogStream {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        if let Some(ref val) = self.log_stream_name {
   63     63   
            ser.write_string(&SEARCHEDLOGSTREAM_MEMBER_LOG_STREAM_NAME, val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.searched_completely {
   66     66   
            ser.write_boolean(&SEARCHEDLOGSTREAM_MEMBER_SEARCHED_COMPLETELY, *val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl SearchedLogStream {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&SEARCHEDLOGSTREAM_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&SEARCHEDLOGSTREAM_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.log_stream_name = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.searched_completely = Some(deser.read_boolean(member)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
   97     97   
        Ok(builder.build())
   98     98   
    }
   99     99   
}
         100  +
impl SearchedLogStream {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  100    111   
impl SearchedLogStream {
  101    112   
    /// Creates a new builder-style object to manufacture [`SearchedLogStream`](crate::types::SearchedLogStream).
  102    113   
    pub fn builder() -> crate::types::builders::SearchedLogStreamBuilder {
  103    114   
        crate::types::builders::SearchedLogStreamBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`SearchedLogStream`](crate::types::SearchedLogStream).
  108    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  109    120   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_split_string.rs

@@ -33,33 +128,137 @@
   53     53   
                    }
   54     54   
                    Ok(())
   55     55   
                },
   56     56   
            )?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl SplitString {
   62     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   63         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   64         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   65     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        #[allow(unused_variables, unused_mut)]
   67     67   
        let mut builder = Self::builder();
   68     68   
        #[allow(
   69     69   
            unused_variables,
   70     70   
            unreachable_code,
   71     71   
            clippy::single_match,
   72     72   
            clippy::match_single_binding,
   73     73   
            clippy::diverging_sub_expression
   74     74   
        )]
   75         -
        deserializer.read_struct(&SPLITSTRING_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&SPLITSTRING_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78     78   
                    builder.entries = Some({
   79         -
                        let container = if let Some(cap) = deser.container_size() {
   80         -
                            Vec::with_capacity(cap)
   81         -
                        } else {
   82         -
                            Vec::new()
   83         -
                        };
   84         -
                        deser.read_list(member, container, |mut list, deser| {
   85         -
                            list.push(crate::types::SplitStringEntry::deserialize(deser)?);
   86         -
                            Ok(list)
   87         -
                        })?
          79  +
                        let mut container = Vec::new();
          80  +
                        deser.read_list(member, &mut |deser| {
          81  +
                            container.push(crate::types::SplitStringEntry::deserialize(deser)?);
          82  +
                            Ok(())
          83  +
                        })?;
          84  +
                        container
   88     85   
                    });
   89     86   
                }
   90     87   
                _ => {}
   91     88   
            }
   92     89   
            Ok(())
   93     90   
        })?;
          91  +
        builder.entries = builder.entries.or(Some(Vec::new()));
   94     92   
        builder
   95     93   
            .build()
   96     94   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   97     95   
    }
   98     96   
}
          97  +
impl SplitString {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   99    108   
impl SplitString {
  100    109   
    /// Creates a new builder-style object to manufacture [`SplitString`](crate::types::SplitString).
  101    110   
    pub fn builder() -> crate::types::builders::SplitStringBuilder {
  102    111   
        crate::types::builders::SplitStringBuilder::default()
  103    112   
    }
  104    113   
}
  105    114   
  106    115   
/// A builder for [`SplitString`](crate::types::SplitString).
  107    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  108    117   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_split_string_entry.rs

@@ -47,47 +135,148 @@
   67     67   
        }
   68     68   
        {
   69     69   
            let val = &self.delimiter;
   70     70   
            ser.write_string(&SPLITSTRINGENTRY_MEMBER_DELIMITER, val)?;
   71     71   
        }
   72     72   
        Ok(())
   73     73   
    }
   74     74   
}
   75     75   
impl SplitStringEntry {
   76     76   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   77         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   78         -
        deserializer: &mut D,
          77  +
    pub fn deserialize(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   79     79   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        #[allow(unused_variables, unused_mut)]
   81     81   
        let mut builder = Self::builder();
   82     82   
        #[allow(
   83     83   
            unused_variables,
   84     84   
            unreachable_code,
   85     85   
            clippy::single_match,
   86     86   
            clippy::match_single_binding,
   87     87   
            clippy::diverging_sub_expression
   88     88   
        )]
   89         -
        deserializer.read_struct(&SPLITSTRINGENTRY_SCHEMA, (), |_, member, deser| {
          89  +
        deserializer.read_struct(&SPLITSTRINGENTRY_SCHEMA, &mut |member, deser| {
   90     90   
            match member.member_index() {
   91     91   
                Some(0) => {
   92     92   
                    builder.source = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                Some(1) => {
   95     95   
                    builder.delimiter = Some(deser.read_string(member)?);
   96     96   
                }
   97     97   
                _ => {}
   98     98   
            }
   99     99   
            Ok(())
  100    100   
        })?;
         101  +
        builder.source = builder.source.or(Some(String::new()));
         102  +
        builder.delimiter = builder.delimiter.or(Some(String::new()));
  101    103   
        builder
  102    104   
            .build()
  103    105   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  104    106   
    }
  105    107   
}
         108  +
impl SplitStringEntry {
         109  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         110  +
    pub fn deserialize_with_response(
         111  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         112  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         113  +
        _status: u16,
         114  +
        _body: &[u8],
         115  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         116  +
        Self::deserialize(deserializer)
         117  +
    }
         118  +
}
  106    119   
impl SplitStringEntry {
  107    120   
    /// Creates a new builder-style object to manufacture [`SplitStringEntry`](crate::types::SplitStringEntry).
  108    121   
    pub fn builder() -> crate::types::builders::SplitStringEntryBuilder {
  109    122   
        crate::types::builders::SplitStringEntryBuilder::default()
  110    123   
    }
  111    124   
}
  112    125   
  113    126   
/// A builder for [`SplitStringEntry`](crate::types::SplitStringEntry).
  114    127   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  115    128   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_start_live_tail_response_stream.rs

@@ -23,23 +0,126 @@
   43     43   
    }
   44     44   
    /// Returns true if this is a [`SessionUpdate`](crate::types::StartLiveTailResponseStream::SessionUpdate).
   45     45   
    pub fn is_session_update(&self) -> bool {
   46     46   
        self.as_session_update().is_ok()
   47     47   
    }
   48     48   
    /// Returns true if the enum instance is the `Unknown` variant.
   49     49   
    pub fn is_unknown(&self) -> bool {
   50     50   
        matches!(self, Self::Unknown)
   51     51   
    }
   52     52   
}
          53  +
static STARTLIVETAILRESPONSESTREAM_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          54  +
    "com.amazonaws.cloudwatchlogs#StartLiveTailResponseStream",
          55  +
    "com.amazonaws.cloudwatchlogs",
          56  +
    "StartLiveTailResponseStream",
          57  +
);
          58  +
static STARTLIVETAILRESPONSESTREAM_MEMBER_SESSIONSTART: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          59  +
    ::aws_smithy_schema::ShapeId::from_static(
          60  +
        "com.amazonaws.cloudwatchlogs#StartLiveTailResponseStream$sessionStart",
          61  +
        "com.amazonaws.cloudwatchlogs",
          62  +
        "StartLiveTailResponseStream",
          63  +
    ),
          64  +
    ::aws_smithy_schema::ShapeType::Structure,
          65  +
    "sessionStart",
          66  +
    0,
          67  +
);
          68  +
static STARTLIVETAILRESPONSESTREAM_MEMBER_SESSIONUPDATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          69  +
    ::aws_smithy_schema::ShapeId::from_static(
          70  +
        "com.amazonaws.cloudwatchlogs#StartLiveTailResponseStream$sessionUpdate",
          71  +
        "com.amazonaws.cloudwatchlogs",
          72  +
        "StartLiveTailResponseStream",
          73  +
    ),
          74  +
    ::aws_smithy_schema::ShapeType::Structure,
          75  +
    "sessionUpdate",
          76  +
    1,
          77  +
);
          78  +
static STARTLIVETAILRESPONSESTREAM_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          79  +
    STARTLIVETAILRESPONSESTREAM_SCHEMA_ID,
          80  +
    ::aws_smithy_schema::ShapeType::Union,
          81  +
    &[
          82  +
        &STARTLIVETAILRESPONSESTREAM_MEMBER_SESSIONSTART,
          83  +
        &STARTLIVETAILRESPONSESTREAM_MEMBER_SESSIONUPDATE,
          84  +
    ],
          85  +
)
          86  +
.with_streaming();
          87  +
impl StartLiveTailResponseStream {
          88  +
    /// The schema for this shape.
          89  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTLIVETAILRESPONSESTREAM_SCHEMA;
          90  +
}
          91  +
impl ::aws_smithy_schema::serde::SerializableStruct for StartLiveTailResponseStream {
          92  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          93  +
    fn serialize_members(
          94  +
        &self,
          95  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          96  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          97  +
        match self {
          98  +
            Self::SessionStart(val) => {
          99  +
                ser.write_struct(&STARTLIVETAILRESPONSESTREAM_MEMBER_SESSIONSTART, val)?;
         100  +
            }
         101  +
            Self::SessionUpdate(val) => {
         102  +
                ser.write_struct(&STARTLIVETAILRESPONSESTREAM_MEMBER_SESSIONUPDATE, val)?;
         103  +
            }
         104  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         105  +
        }
         106  +
        Ok(())
         107  +
    }
         108  +
}
         109  +
impl StartLiveTailResponseStream {
         110  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         111  +
    pub fn deserialize(
         112  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         113  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         114  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         115  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         116  +
        deserializer.read_struct(&STARTLIVETAILRESPONSESTREAM_SCHEMA, &mut |member, deser| {
         117  +
            result = ::std::option::Option::Some(match member.member_index() {
         118  +
                Some(0) => Self::SessionStart(crate::types::LiveTailSessionStart::deserialize(deser)?),
         119  +
                Some(1) => Self::SessionUpdate(crate::types::LiveTailSessionUpdate::deserialize(deser)?),
         120  +
                _ => Self::Unknown,
         121  +
            });
         122  +
            Ok(())
         123  +
        })?;
         124  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         125  +
    }
         126  +
}

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_subscription_filter.rs

@@ -56,56 +206,206 @@
   76     76   
    "com.amazonaws.cloudwatchlogs",
   77     77   
    "SubscriptionFilter",
   78     78   
);
   79     79   
static SUBSCRIPTIONFILTER_MEMBER_FILTER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$filterName",
   82     82   
        "com.amazonaws.cloudwatchlogs",
   83     83   
        "SubscriptionFilter",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "filter_name",
          86  +
    "filterName",
   87     87   
    0,
   88     88   
);
   89     89   
static SUBSCRIPTIONFILTER_MEMBER_LOG_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$logGroupName",
   92     92   
        "com.amazonaws.cloudwatchlogs",
   93     93   
        "SubscriptionFilter",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "log_group_name",
          96  +
    "logGroupName",
   97     97   
    1,
   98     98   
);
   99     99   
static SUBSCRIPTIONFILTER_MEMBER_FILTER_PATTERN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$filterPattern",
  102    102   
        "com.amazonaws.cloudwatchlogs",
  103    103   
        "SubscriptionFilter",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "filter_pattern",
         106  +
    "filterPattern",
  107    107   
    2,
  108    108   
);
  109    109   
static SUBSCRIPTIONFILTER_MEMBER_DESTINATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$destinationArn",
  112    112   
        "com.amazonaws.cloudwatchlogs",
  113    113   
        "SubscriptionFilter",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "destination_arn",
         116  +
    "destinationArn",
  117    117   
    3,
  118    118   
);
  119    119   
static SUBSCRIPTIONFILTER_MEMBER_ROLE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$roleArn",
  122    122   
        "com.amazonaws.cloudwatchlogs",
  123    123   
        "SubscriptionFilter",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "role_arn",
         126  +
    "roleArn",
  127    127   
    4,
  128    128   
);
  129    129   
static SUBSCRIPTIONFILTER_MEMBER_DISTRIBUTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$distribution",
  132    132   
        "com.amazonaws.cloudwatchlogs",
  133    133   
        "SubscriptionFilter",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::String,
  136    136   
    "distribution",
  137    137   
    5,
  138    138   
);
  139    139   
static SUBSCRIPTIONFILTER_MEMBER_APPLY_ON_TRANSFORMED_LOGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  140    140   
    ::aws_smithy_schema::ShapeId::from_static(
  141    141   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$applyOnTransformedLogs",
  142    142   
        "com.amazonaws.cloudwatchlogs",
  143    143   
        "SubscriptionFilter",
  144    144   
    ),
  145    145   
    ::aws_smithy_schema::ShapeType::Boolean,
  146         -
    "apply_on_transformed_logs",
         146  +
    "applyOnTransformedLogs",
  147    147   
    6,
  148    148   
);
  149    149   
static SUBSCRIPTIONFILTER_MEMBER_CREATION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  150    150   
    ::aws_smithy_schema::ShapeId::from_static(
  151    151   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$creationTime",
  152    152   
        "com.amazonaws.cloudwatchlogs",
  153    153   
        "SubscriptionFilter",
  154    154   
    ),
  155    155   
    ::aws_smithy_schema::ShapeType::Long,
  156         -
    "creation_time",
         156  +
    "creationTime",
  157    157   
    7,
  158    158   
);
  159    159   
static SUBSCRIPTIONFILTER_MEMBER_FIELD_SELECTION_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  160    160   
    ::aws_smithy_schema::ShapeId::from_static(
  161    161   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$fieldSelectionCriteria",
  162    162   
        "com.amazonaws.cloudwatchlogs",
  163    163   
        "SubscriptionFilter",
  164    164   
    ),
  165    165   
    ::aws_smithy_schema::ShapeType::String,
  166         -
    "field_selection_criteria",
         166  +
    "fieldSelectionCriteria",
  167    167   
    8,
  168    168   
);
  169    169   
static SUBSCRIPTIONFILTER_MEMBER_EMIT_SYSTEM_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.cloudwatchlogs#SubscriptionFilter$emitSystemFields",
  172    172   
        "com.amazonaws.cloudwatchlogs",
  173    173   
        "SubscriptionFilter",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::List,
  176         -
    "emit_system_fields",
         176  +
    "emitSystemFields",
  177    177   
    9,
  178    178   
);
  179    179   
static SUBSCRIPTIONFILTER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  180    180   
    SUBSCRIPTIONFILTER_SCHEMA_ID,
  181    181   
    ::aws_smithy_schema::ShapeType::Structure,
  182    182   
    &[
  183    183   
        &SUBSCRIPTIONFILTER_MEMBER_FILTER_NAME,
  184    184   
        &SUBSCRIPTIONFILTER_MEMBER_LOG_GROUP_NAME,
  185    185   
        &SUBSCRIPTIONFILTER_MEMBER_FILTER_PATTERN,
  186    186   
        &SUBSCRIPTIONFILTER_MEMBER_DESTINATION_ARN,
@@ -219,219 +339,340 @@
  239    239   
                    }
  240    240   
                    Ok(())
  241    241   
                },
  242    242   
            )?;
  243    243   
        }
  244    244   
        Ok(())
  245    245   
    }
  246    246   
}
  247    247   
impl SubscriptionFilter {
  248    248   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  249         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  250         -
        deserializer: &mut D,
         249  +
    pub fn deserialize(
         250  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  251    251   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  252    252   
        #[allow(unused_variables, unused_mut)]
  253    253   
        let mut builder = Self::builder();
  254    254   
        #[allow(
  255    255   
            unused_variables,
  256    256   
            unreachable_code,
  257    257   
            clippy::single_match,
  258    258   
            clippy::match_single_binding,
  259    259   
            clippy::diverging_sub_expression
  260    260   
        )]
  261         -
        deserializer.read_struct(&SUBSCRIPTIONFILTER_SCHEMA, (), |_, member, deser| {
         261  +
        deserializer.read_struct(&SUBSCRIPTIONFILTER_SCHEMA, &mut |member, deser| {
  262    262   
            match member.member_index() {
  263    263   
                Some(0) => {
  264    264   
                    builder.filter_name = Some(deser.read_string(member)?);
  265    265   
                }
  266    266   
                Some(1) => {
  267    267   
                    builder.log_group_name = Some(deser.read_string(member)?);
  268    268   
                }
  269    269   
                Some(2) => {
  270    270   
                    builder.filter_pattern = Some(deser.read_string(member)?);
  271    271   
                }
  272    272   
                Some(3) => {
  273    273   
                    builder.destination_arn = Some(deser.read_string(member)?);
  274    274   
                }
  275    275   
                Some(4) => {
  276    276   
                    builder.role_arn = Some(deser.read_string(member)?);
  277    277   
                }
  278    278   
                Some(5) => {
  279    279   
                    builder.distribution = Some(crate::types::Distribution::from(deser.read_string(member)?.as_str()));
  280    280   
                }
  281    281   
                Some(6) => {
  282    282   
                    builder.apply_on_transformed_logs = Some(deser.read_boolean(member)?);
  283    283   
                }
  284    284   
                Some(7) => {
  285    285   
                    builder.creation_time = Some(deser.read_long(member)?);
  286    286   
                }
  287    287   
                Some(8) => {
  288    288   
                    builder.field_selection_criteria = Some(deser.read_string(member)?);
  289    289   
                }
  290    290   
                Some(9) => {
  291         -
                    builder.emit_system_fields = Some({
  292         -
                        let container = if let Some(cap) = deser.container_size() {
  293         -
                            Vec::with_capacity(cap)
  294         -
                        } else {
  295         -
                            Vec::new()
  296         -
                        };
  297         -
                        deser.read_list(member, container, |mut list, deser| {
  298         -
                            list.push(deser.read_string(member)?);
  299         -
                            Ok(list)
  300         -
                        })?
  301         -
                    });
         291  +
                    builder.emit_system_fields = Some(deser.read_string_list(member)?);
  302    292   
                }
  303    293   
                _ => {}
  304    294   
            }
  305    295   
            Ok(())
  306    296   
        })?;
  307    297   
        Ok(builder.build())
  308    298   
    }
  309    299   
}
         300  +
impl SubscriptionFilter {
         301  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         302  +
    pub fn deserialize_with_response(
         303  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         304  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         305  +
        _status: u16,
         306  +
        _body: &[u8],
         307  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         308  +
        Self::deserialize(deserializer)
         309  +
    }
         310  +
}
  310    311   
impl SubscriptionFilter {
  311    312   
    /// Creates a new builder-style object to manufacture [`SubscriptionFilter`](crate::types::SubscriptionFilter).
  312    313   
    pub fn builder() -> crate::types::builders::SubscriptionFilterBuilder {
  313    314   
        crate::types::builders::SubscriptionFilterBuilder::default()
  314    315   
    }
  315    316   
}
  316    317   
  317    318   
/// A builder for [`SubscriptionFilter`](crate::types::SubscriptionFilter).
  318    319   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  319    320   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_substitute_string.rs

@@ -36,36 +131,140 @@
   56     56   
                    }
   57     57   
                    Ok(())
   58     58   
                },
   59     59   
            )?;
   60     60   
        }
   61     61   
        Ok(())
   62     62   
    }
   63     63   
}
   64     64   
impl SubstituteString {
   65     65   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   66         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   67         -
        deserializer: &mut D,
          66  +
    pub fn deserialize(
          67  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   68     68   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        #[allow(unused_variables, unused_mut)]
   70     70   
        let mut builder = Self::builder();
   71     71   
        #[allow(
   72     72   
            unused_variables,
   73     73   
            unreachable_code,
   74     74   
            clippy::single_match,
   75     75   
            clippy::match_single_binding,
   76     76   
            clippy::diverging_sub_expression
   77     77   
        )]
   78         -
        deserializer.read_struct(&SUBSTITUTESTRING_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&SUBSTITUTESTRING_SCHEMA, &mut |member, deser| {
   79     79   
            match member.member_index() {
   80     80   
                Some(0) => {
   81     81   
                    builder.entries = Some({
   82         -
                        let container = if let Some(cap) = deser.container_size() {
   83         -
                            Vec::with_capacity(cap)
   84         -
                        } else {
   85         -
                            Vec::new()
   86         -
                        };
   87         -
                        deser.read_list(member, container, |mut list, deser| {
   88         -
                            list.push(crate::types::SubstituteStringEntry::deserialize(deser)?);
   89         -
                            Ok(list)
   90         -
                        })?
          82  +
                        let mut container = Vec::new();
          83  +
                        deser.read_list(member, &mut |deser| {
          84  +
                            container.push(crate::types::SubstituteStringEntry::deserialize(deser)?);
          85  +
                            Ok(())
          86  +
                        })?;
          87  +
                        container
   91     88   
                    });
   92     89   
                }
   93     90   
                _ => {}
   94     91   
            }
   95     92   
            Ok(())
   96     93   
        })?;
          94  +
        builder.entries = builder.entries.or(Some(Vec::new()));
   97     95   
        builder
   98     96   
            .build()
   99     97   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  100     98   
    }
  101     99   
}
         100  +
impl SubstituteString {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  102    111   
impl SubstituteString {
  103    112   
    /// Creates a new builder-style object to manufacture [`SubstituteString`](crate::types::SubstituteString).
  104    113   
    pub fn builder() -> crate::types::builders::SubstituteStringBuilder {
  105    114   
        crate::types::builders::SubstituteStringBuilder::default()
  106    115   
    }
  107    116   
}
  108    117   
  109    118   
/// A builder for [`SubstituteString`](crate::types::SubstituteString).
  110    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  111    120   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_substitute_string_entry.rs

@@ -72,72 +163,177 @@
   92     92   
        }
   93     93   
        {
   94     94   
            let val = &self.to;
   95     95   
            ser.write_string(&SUBSTITUTESTRINGENTRY_MEMBER_TO, val)?;
   96     96   
        }
   97     97   
        Ok(())
   98     98   
    }
   99     99   
}
  100    100   
impl SubstituteStringEntry {
  101    101   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  102         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  103         -
        deserializer: &mut D,
         102  +
    pub fn deserialize(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  104    104   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  105    105   
        #[allow(unused_variables, unused_mut)]
  106    106   
        let mut builder = Self::builder();
  107    107   
        #[allow(
  108    108   
            unused_variables,
  109    109   
            unreachable_code,
  110    110   
            clippy::single_match,
  111    111   
            clippy::match_single_binding,
  112    112   
            clippy::diverging_sub_expression
  113    113   
        )]
  114         -
        deserializer.read_struct(&SUBSTITUTESTRINGENTRY_SCHEMA, (), |_, member, deser| {
         114  +
        deserializer.read_struct(&SUBSTITUTESTRINGENTRY_SCHEMA, &mut |member, deser| {
  115    115   
            match member.member_index() {
  116    116   
                Some(0) => {
  117    117   
                    builder.source = Some(deser.read_string(member)?);
  118    118   
                }
  119    119   
                Some(1) => {
  120    120   
                    builder.from = Some(deser.read_string(member)?);
  121    121   
                }
  122    122   
                Some(2) => {
  123    123   
                    builder.to = Some(deser.read_string(member)?);
  124    124   
                }
  125    125   
                _ => {}
  126    126   
            }
  127    127   
            Ok(())
  128    128   
        })?;
         129  +
        builder.source = builder.source.or(Some(String::new()));
         130  +
        builder.from = builder.from.or(Some(String::new()));
         131  +
        builder.to = builder.to.or(Some(String::new()));
  129    132   
        builder
  130    133   
            .build()
  131    134   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  132    135   
    }
  133    136   
}
         137  +
impl SubstituteStringEntry {
         138  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         139  +
    pub fn deserialize_with_response(
         140  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         141  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         142  +
        _status: u16,
         143  +
        _body: &[u8],
         144  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         145  +
        Self::deserialize(deserializer)
         146  +
    }
         147  +
}
  134    148   
impl SubstituteStringEntry {
  135    149   
    /// Creates a new builder-style object to manufacture [`SubstituteStringEntry`](crate::types::SubstituteStringEntry).
  136    150   
    pub fn builder() -> crate::types::builders::SubstituteStringEntryBuilder {
  137    151   
        crate::types::builders::SubstituteStringEntryBuilder::default()
  138    152   
    }
  139    153   
}
  140    154   
  141    155   
/// A builder for [`SubstituteStringEntry`](crate::types::SubstituteStringEntry).
  142    156   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  143    157   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_suppression_period.rs

@@ -14,14 +130,141 @@
   34     34   
    "value",
   35     35   
    0,
   36     36   
);
   37     37   
static SUPPRESSIONPERIOD_MEMBER_SUPPRESSION_UNIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.cloudwatchlogs#SuppressionPeriod$suppressionUnit",
   40     40   
        "com.amazonaws.cloudwatchlogs",
   41     41   
        "SuppressionPeriod",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "suppression_unit",
          44  +
    "suppressionUnit",
   45     45   
    1,
   46     46   
);
   47     47   
static SUPPRESSIONPERIOD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    SUPPRESSIONPERIOD_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&SUPPRESSIONPERIOD_MEMBER_VALUE, &SUPPRESSIONPERIOD_MEMBER_SUPPRESSION_UNIT],
   51     51   
);
   52     52   
impl SuppressionPeriod {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SUPPRESSIONPERIOD_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for SuppressionPeriod {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        {
   63     63   
            let val = &self.value;
   64     64   
            ser.write_integer(&SUPPRESSIONPERIOD_MEMBER_VALUE, *val)?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.suppression_unit {
   67     67   
            ser.write_string(&SUPPRESSIONPERIOD_MEMBER_SUPPRESSION_UNIT, val.as_str())?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl SuppressionPeriod {
   73     73   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   74         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   75         -
        deserializer: &mut D,
          74  +
    pub fn deserialize(
          75  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   76     76   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   77     77   
        #[allow(unused_variables, unused_mut)]
   78     78   
        let mut builder = Self::builder();
   79     79   
        #[allow(
   80     80   
            unused_variables,
   81     81   
            unreachable_code,
   82     82   
            clippy::single_match,
   83     83   
            clippy::match_single_binding,
   84     84   
            clippy::diverging_sub_expression
   85     85   
        )]
   86         -
        deserializer.read_struct(&SUPPRESSIONPERIOD_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&SUPPRESSIONPERIOD_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.value = Some(deser.read_integer(member)?);
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.suppression_unit = Some(crate::types::SuppressionUnit::from(deser.read_string(member)?.as_str()));
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        Ok(builder.build())
   99     99   
    }
  100    100   
}
         101  +
impl SuppressionPeriod {
         102  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         103  +
    pub fn deserialize_with_response(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         105  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         106  +
        _status: u16,
         107  +
        _body: &[u8],
         108  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         109  +
        Self::deserialize(deserializer)
         110  +
    }
         111  +
}
  101    112   
impl SuppressionPeriod {
  102    113   
    /// Creates a new builder-style object to manufacture [`SuppressionPeriod`](crate::types::SuppressionPeriod).
  103    114   
    pub fn builder() -> crate::types::builders::SuppressionPeriodBuilder {
  104    115   
        crate::types::builders::SuppressionPeriodBuilder::default()
  105    116   
    }
  106    117   
}
  107    118   
  108    119   
/// A builder for [`SuppressionPeriod`](crate::types::SuppressionPeriod).
  109    120   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  110    121   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_transformed_log_record.rs

@@ -10,10 +156,167 @@
   30     30   
    "com.amazonaws.cloudwatchlogs",
   31     31   
    "TransformedLogRecord",
   32     32   
);
   33     33   
static TRANSFORMEDLOGRECORD_MEMBER_EVENT_NUMBER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.cloudwatchlogs#TransformedLogRecord$eventNumber",
   36     36   
        "com.amazonaws.cloudwatchlogs",
   37     37   
        "TransformedLogRecord",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Long,
   40         -
    "event_number",
          40  +
    "eventNumber",
   41     41   
    0,
   42     42   
);
   43     43   
static TRANSFORMEDLOGRECORD_MEMBER_EVENT_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.cloudwatchlogs#TransformedLogRecord$eventMessage",
   46     46   
        "com.amazonaws.cloudwatchlogs",
   47     47   
        "TransformedLogRecord",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "event_message",
          50  +
    "eventMessage",
   51     51   
    1,
   52     52   
);
   53     53   
static TRANSFORMEDLOGRECORD_MEMBER_TRANSFORMED_EVENT_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.cloudwatchlogs#TransformedLogRecord$transformedEventMessage",
   56     56   
        "com.amazonaws.cloudwatchlogs",
   57     57   
        "TransformedLogRecord",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "transformed_event_message",
          60  +
    "transformedEventMessage",
   61     61   
    2,
   62     62   
);
   63     63   
static TRANSFORMEDLOGRECORD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    TRANSFORMEDLOGRECORD_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &TRANSFORMEDLOGRECORD_MEMBER_EVENT_NUMBER,
   68     68   
        &TRANSFORMEDLOGRECORD_MEMBER_EVENT_MESSAGE,
   69     69   
        &TRANSFORMEDLOGRECORD_MEMBER_TRANSFORMED_EVENT_MESSAGE,
   70     70   
    ],
   71     71   
);
   72     72   
impl TransformedLogRecord {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRANSFORMEDLOGRECORD_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for TransformedLogRecord {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        {
   83     83   
            let val = &self.event_number;
   84     84   
            ser.write_long(&TRANSFORMEDLOGRECORD_MEMBER_EVENT_NUMBER, *val)?;
   85     85   
        }
   86     86   
        if let Some(ref val) = self.event_message {
   87     87   
            ser.write_string(&TRANSFORMEDLOGRECORD_MEMBER_EVENT_MESSAGE, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.transformed_event_message {
   90     90   
            ser.write_string(&TRANSFORMEDLOGRECORD_MEMBER_TRANSFORMED_EVENT_MESSAGE, val)?;
   91     91   
        }
   92     92   
        Ok(())
   93     93   
    }
   94     94   
}
   95     95   
impl TransformedLogRecord {
   96     96   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   97         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   98         -
        deserializer: &mut D,
          97  +
    pub fn deserialize(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   99     99   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  100    100   
        #[allow(unused_variables, unused_mut)]
  101    101   
        let mut builder = Self::builder();
  102    102   
        #[allow(
  103    103   
            unused_variables,
  104    104   
            unreachable_code,
  105    105   
            clippy::single_match,
  106    106   
            clippy::match_single_binding,
  107    107   
            clippy::diverging_sub_expression
  108    108   
        )]
  109         -
        deserializer.read_struct(&TRANSFORMEDLOGRECORD_SCHEMA, (), |_, member, deser| {
         109  +
        deserializer.read_struct(&TRANSFORMEDLOGRECORD_SCHEMA, &mut |member, deser| {
  110    110   
            match member.member_index() {
  111    111   
                Some(0) => {
  112    112   
                    builder.event_number = Some(deser.read_long(member)?);
  113    113   
                }
  114    114   
                Some(1) => {
  115    115   
                    builder.event_message = Some(deser.read_string(member)?);
  116    116   
                }
  117    117   
                Some(2) => {
  118    118   
                    builder.transformed_event_message = Some(deser.read_string(member)?);
  119    119   
                }
  120    120   
                _ => {}
  121    121   
            }
  122    122   
            Ok(())
  123    123   
        })?;
  124    124   
        Ok(builder.build())
  125    125   
    }
  126    126   
}
         127  +
impl TransformedLogRecord {
         128  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         129  +
    pub fn deserialize_with_response(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         131  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         132  +
        _status: u16,
         133  +
        _body: &[u8],
         134  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         135  +
        Self::deserialize(deserializer)
         136  +
    }
         137  +
}
  127    138   
impl TransformedLogRecord {
  128    139   
    /// Creates a new builder-style object to manufacture [`TransformedLogRecord`](crate::types::TransformedLogRecord).
  129    140   
    pub fn builder() -> crate::types::builders::TransformedLogRecordBuilder {
  130    141   
        crate::types::builders::TransformedLogRecordBuilder::default()
  131    142   
    }
  132    143   
}
  133    144   
  134    145   
/// A builder for [`TransformedLogRecord`](crate::types::TransformedLogRecord).
  135    146   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  136    147   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/types/_trim_string.rs

@@ -1,1 +128,130 @@
   17     17   
}
   18     18   
static TRIMSTRING_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.cloudwatchlogs#TrimString", "com.amazonaws.cloudwatchlogs", "TrimString");
   20     20   
static TRIMSTRING_MEMBER_WITH_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "com.amazonaws.cloudwatchlogs#TrimString$withKeys",
   23     23   
        "com.amazonaws.cloudwatchlogs",
   24     24   
        "TrimString",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::List,
   27         -
    "with_keys",
          27  +
    "withKeys",
   28     28   
    0,
   29     29   
);
   30     30   
static TRIMSTRING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    TRIMSTRING_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&TRIMSTRING_MEMBER_WITH_KEYS],
   34     34   
);
   35     35   
impl TrimString {
   36     36   
    /// The schema for this shape.
   37     37   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRIMSTRING_SCHEMA;
   38     38   
}
   39     39   
impl ::aws_smithy_schema::serde::SerializableStruct for TrimString {
   40     40   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     41   
    fn serialize_members(
   42     42   
        &self,
   43     43   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     44   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        {
   46     46   
            let val = &self.with_keys;
   47     47   
   48     48   
            ser.write_list(
   49     49   
                &TRIMSTRING_MEMBER_WITH_KEYS,
   50     50   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   51     51   
                    for item in val {
   52     52   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   53     53   
                    }
   54     54   
                    Ok(())
   55     55   
                },
   56     56   
            )?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl TrimString {
   62     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   63         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   64         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   65     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        #[allow(unused_variables, unused_mut)]
   67     67   
        let mut builder = Self::builder();
   68     68   
        #[allow(
   69     69   
            unused_variables,
   70     70   
            unreachable_code,
   71     71   
            clippy::single_match,
   72     72   
            clippy::match_single_binding,
   73     73   
            clippy::diverging_sub_expression
   74     74   
        )]
   75         -
        deserializer.read_struct(&TRIMSTRING_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&TRIMSTRING_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78         -
                    builder.with_keys = Some({
   79         -
                        let container = if let Some(cap) = deser.container_size() {
   80         -
                            Vec::with_capacity(cap)
   81         -
                        } else {
   82         -
                            Vec::new()
   83         -
                        };
   84         -
                        deser.read_list(member, container, |mut list, deser| {
   85         -
                            list.push(deser.read_string(member)?);
   86         -
                            Ok(list)
   87         -
                        })?
   88         -
                    });
          78  +
                    builder.with_keys = Some(deser.read_string_list(member)?);
   89     79   
                }
   90     80   
                _ => {}
   91     81   
            }
   92     82   
            Ok(())
   93     83   
        })?;
          84  +
        builder.with_keys = builder.with_keys.or(Some(Vec::new()));
   94     85   
        builder
   95     86   
            .build()
   96     87   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   97     88   
    }
   98     89   
}
          90  +
impl TrimString {
          91  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          92  +
    pub fn deserialize_with_response(
          93  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          94  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          95  +
        _status: u16,
          96  +
        _body: &[u8],
          97  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          98  +
        Self::deserialize(deserializer)
          99  +
    }
         100  +
}
   99    101   
impl TrimString {
  100    102   
    /// Creates a new builder-style object to manufacture [`TrimString`](crate::types::TrimString).
  101    103   
    pub fn builder() -> crate::types::builders::TrimStringBuilder {
  102    104   
        crate::types::builders::TrimStringBuilder::default()
  103    105   
    }
  104    106   
}
  105    107   
  106    108   
/// A builder for [`TrimString`](crate::types::TrimString).
  107    109   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  108    110   
#[non_exhaustive]