AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_delivery_channel.rs

@@ -42,42 +228,239 @@
   62     62   
    "name",
   63     63   
    0,
   64     64   
);
   65     65   
static DELIVERYCHANNEL_MEMBER_S3_BUCKET_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.configservice#DeliveryChannel$s3BucketName",
   68     68   
        "com.amazonaws.configservice",
   69     69   
        "DeliveryChannel",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "s3_bucket_name",
          72  +
    "s3BucketName",
   73     73   
    1,
   74     74   
);
   75     75   
static DELIVERYCHANNEL_MEMBER_S3_KEY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.configservice#DeliveryChannel$s3KeyPrefix",
   78     78   
        "com.amazonaws.configservice",
   79     79   
        "DeliveryChannel",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "s3_key_prefix",
          82  +
    "s3KeyPrefix",
   83     83   
    2,
   84     84   
);
   85     85   
static DELIVERYCHANNEL_MEMBER_S3_KMS_KEY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.configservice#DeliveryChannel$s3KmsKeyArn",
   88     88   
        "com.amazonaws.configservice",
   89     89   
        "DeliveryChannel",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "s3_kms_key_arn",
          92  +
    "s3KmsKeyArn",
   93     93   
    3,
   94     94   
);
   95     95   
static DELIVERYCHANNEL_MEMBER_SNS_TOPIC_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.configservice#DeliveryChannel$snsTopicARN",
   98     98   
        "com.amazonaws.configservice",
   99     99   
        "DeliveryChannel",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "sns_topic_arn",
         102  +
    "snsTopicARN",
  103    103   
    4,
  104    104   
);
  105    105   
static DELIVERYCHANNEL_MEMBER_CONFIG_SNAPSHOT_DELIVERY_PROPERTIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.configservice#DeliveryChannel$configSnapshotDeliveryProperties",
  108    108   
        "com.amazonaws.configservice",
  109    109   
        "DeliveryChannel",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::Structure,
  112         -
    "config_snapshot_delivery_properties",
         112  +
    "configSnapshotDeliveryProperties",
  113    113   
    5,
  114    114   
);
  115    115   
static DELIVERYCHANNEL_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  116    116   
    DELIVERYCHANNEL_SCHEMA_ID,
  117    117   
    ::aws_smithy_schema::ShapeType::Structure,
  118    118   
    &[
  119    119   
        &DELIVERYCHANNEL_MEMBER_NAME,
  120    120   
        &DELIVERYCHANNEL_MEMBER_S3_BUCKET_NAME,
  121    121   
        &DELIVERYCHANNEL_MEMBER_S3_KEY_PREFIX,
  122    122   
        &DELIVERYCHANNEL_MEMBER_S3_KMS_KEY_ARN,
  123    123   
        &DELIVERYCHANNEL_MEMBER_SNS_TOPIC_ARN,
  124    124   
        &DELIVERYCHANNEL_MEMBER_CONFIG_SNAPSHOT_DELIVERY_PROPERTIES,
  125    125   
    ],
  126    126   
);
  127    127   
impl DeliveryChannel {
  128    128   
    /// The schema for this shape.
  129    129   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELIVERYCHANNEL_SCHEMA;
  130    130   
}
  131    131   
impl ::aws_smithy_schema::serde::SerializableStruct for DeliveryChannel {
  132    132   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  133    133   
    fn serialize_members(
  134    134   
        &self,
  135    135   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  136    136   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  137    137   
        if let Some(ref val) = self.name {
  138    138   
            ser.write_string(&DELIVERYCHANNEL_MEMBER_NAME, val)?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.s3_bucket_name {
  141    141   
            ser.write_string(&DELIVERYCHANNEL_MEMBER_S3_BUCKET_NAME, val)?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.s3_key_prefix {
  144    144   
            ser.write_string(&DELIVERYCHANNEL_MEMBER_S3_KEY_PREFIX, val)?;
  145    145   
        }
  146    146   
        if let Some(ref val) = self.s3_kms_key_arn {
  147    147   
            ser.write_string(&DELIVERYCHANNEL_MEMBER_S3_KMS_KEY_ARN, val)?;
  148    148   
        }
  149    149   
        if let Some(ref val) = self.sns_topic_arn {
  150    150   
            ser.write_string(&DELIVERYCHANNEL_MEMBER_SNS_TOPIC_ARN, val)?;
  151    151   
        }
  152    152   
        if let Some(ref val) = self.config_snapshot_delivery_properties {
  153    153   
            ser.write_struct(&DELIVERYCHANNEL_MEMBER_CONFIG_SNAPSHOT_DELIVERY_PROPERTIES, val)?;
  154    154   
        }
  155    155   
        Ok(())
  156    156   
    }
  157    157   
}
  158    158   
impl DeliveryChannel {
  159    159   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  160         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  161         -
        deserializer: &mut D,
         160  +
    pub fn deserialize(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  162    162   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  163    163   
        #[allow(unused_variables, unused_mut)]
  164    164   
        let mut builder = Self::builder();
  165    165   
        #[allow(
  166    166   
            unused_variables,
  167    167   
            unreachable_code,
  168    168   
            clippy::single_match,
  169    169   
            clippy::match_single_binding,
  170    170   
            clippy::diverging_sub_expression
  171    171   
        )]
  172         -
        deserializer.read_struct(&DELIVERYCHANNEL_SCHEMA, (), |_, member, deser| {
         172  +
        deserializer.read_struct(&DELIVERYCHANNEL_SCHEMA, &mut |member, deser| {
  173    173   
            match member.member_index() {
  174    174   
                Some(0) => {
  175    175   
                    builder.name = Some(deser.read_string(member)?);
  176    176   
                }
  177    177   
                Some(1) => {
  178    178   
                    builder.s3_bucket_name = Some(deser.read_string(member)?);
  179    179   
                }
  180    180   
                Some(2) => {
  181    181   
                    builder.s3_key_prefix = Some(deser.read_string(member)?);
  182    182   
                }
  183    183   
                Some(3) => {
  184    184   
                    builder.s3_kms_key_arn = Some(deser.read_string(member)?);
  185    185   
                }
  186    186   
                Some(4) => {
  187    187   
                    builder.sns_topic_arn = Some(deser.read_string(member)?);
  188    188   
                }
  189    189   
                Some(5) => {
  190    190   
                    builder.config_snapshot_delivery_properties = Some(crate::types::ConfigSnapshotDeliveryProperties::deserialize(deser)?);
  191    191   
                }
  192    192   
                _ => {}
  193    193   
            }
  194    194   
            Ok(())
  195    195   
        })?;
  196    196   
        Ok(builder.build())
  197    197   
    }
  198    198   
}
         199  +
impl DeliveryChannel {
         200  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         201  +
    pub fn deserialize_with_response(
         202  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         203  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         204  +
        _status: u16,
         205  +
        _body: &[u8],
         206  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         207  +
        Self::deserialize(deserializer)
         208  +
    }
         209  +
}
  199    210   
impl DeliveryChannel {
  200    211   
    /// Creates a new builder-style object to manufacture [`DeliveryChannel`](crate::types::DeliveryChannel).
  201    212   
    pub fn builder() -> crate::types::builders::DeliveryChannelBuilder {
  202    213   
        crate::types::builders::DeliveryChannelBuilder::default()
  203    214   
    }
  204    215   
}
  205    216   
  206    217   
/// A builder for [`DeliveryChannel`](crate::types::DeliveryChannel).
  207    218   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  208    219   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_delivery_channel_status.rs

@@ -27,27 +179,190 @@
   47     47   
    "name",
   48     48   
    0,
   49     49   
);
   50     50   
static DELIVERYCHANNELSTATUS_MEMBER_CONFIG_SNAPSHOT_DELIVERY_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.configservice#DeliveryChannelStatus$configSnapshotDeliveryInfo",
   53     53   
        "com.amazonaws.configservice",
   54     54   
        "DeliveryChannelStatus",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::Structure,
   57         -
    "config_snapshot_delivery_info",
          57  +
    "configSnapshotDeliveryInfo",
   58     58   
    1,
   59     59   
);
   60     60   
static DELIVERYCHANNELSTATUS_MEMBER_CONFIG_HISTORY_DELIVERY_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.configservice#DeliveryChannelStatus$configHistoryDeliveryInfo",
   63     63   
        "com.amazonaws.configservice",
   64     64   
        "DeliveryChannelStatus",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67         -
    "config_history_delivery_info",
          67  +
    "configHistoryDeliveryInfo",
   68     68   
    2,
   69     69   
);
   70     70   
static DELIVERYCHANNELSTATUS_MEMBER_CONFIG_STREAM_DELIVERY_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.configservice#DeliveryChannelStatus$configStreamDeliveryInfo",
   73     73   
        "com.amazonaws.configservice",
   74     74   
        "DeliveryChannelStatus",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::Structure,
   77         -
    "config_stream_delivery_info",
          77  +
    "configStreamDeliveryInfo",
   78     78   
    3,
   79     79   
);
   80     80   
static DELIVERYCHANNELSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   81     81   
    DELIVERYCHANNELSTATUS_SCHEMA_ID,
   82     82   
    ::aws_smithy_schema::ShapeType::Structure,
   83     83   
    &[
   84     84   
        &DELIVERYCHANNELSTATUS_MEMBER_NAME,
   85     85   
        &DELIVERYCHANNELSTATUS_MEMBER_CONFIG_SNAPSHOT_DELIVERY_INFO,
   86     86   
        &DELIVERYCHANNELSTATUS_MEMBER_CONFIG_HISTORY_DELIVERY_INFO,
   87     87   
        &DELIVERYCHANNELSTATUS_MEMBER_CONFIG_STREAM_DELIVERY_INFO,
   88     88   
    ],
   89     89   
);
   90     90   
impl DeliveryChannelStatus {
   91     91   
    /// The schema for this shape.
   92     92   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DELIVERYCHANNELSTATUS_SCHEMA;
   93     93   
}
   94     94   
impl ::aws_smithy_schema::serde::SerializableStruct for DeliveryChannelStatus {
   95     95   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   96     96   
    fn serialize_members(
   97     97   
        &self,
   98     98   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   99     99   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  100    100   
        if let Some(ref val) = self.name {
  101    101   
            ser.write_string(&DELIVERYCHANNELSTATUS_MEMBER_NAME, val)?;
  102    102   
        }
  103    103   
        if let Some(ref val) = self.config_snapshot_delivery_info {
  104    104   
            ser.write_struct(&DELIVERYCHANNELSTATUS_MEMBER_CONFIG_SNAPSHOT_DELIVERY_INFO, val)?;
  105    105   
        }
  106    106   
        if let Some(ref val) = self.config_history_delivery_info {
  107    107   
            ser.write_struct(&DELIVERYCHANNELSTATUS_MEMBER_CONFIG_HISTORY_DELIVERY_INFO, val)?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.config_stream_delivery_info {
  110    110   
            ser.write_struct(&DELIVERYCHANNELSTATUS_MEMBER_CONFIG_STREAM_DELIVERY_INFO, val)?;
  111    111   
        }
  112    112   
        Ok(())
  113    113   
    }
  114    114   
}
  115    115   
impl DeliveryChannelStatus {
  116    116   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  117         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  118         -
        deserializer: &mut D,
         117  +
    pub fn deserialize(
         118  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  119    119   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  120    120   
        #[allow(unused_variables, unused_mut)]
  121    121   
        let mut builder = Self::builder();
  122    122   
        #[allow(
  123    123   
            unused_variables,
  124    124   
            unreachable_code,
  125    125   
            clippy::single_match,
  126    126   
            clippy::match_single_binding,
  127    127   
            clippy::diverging_sub_expression
  128    128   
        )]
  129         -
        deserializer.read_struct(&DELIVERYCHANNELSTATUS_SCHEMA, (), |_, member, deser| {
         129  +
        deserializer.read_struct(&DELIVERYCHANNELSTATUS_SCHEMA, &mut |member, deser| {
  130    130   
            match member.member_index() {
  131    131   
                Some(0) => {
  132    132   
                    builder.name = Some(deser.read_string(member)?);
  133    133   
                }
  134    134   
                Some(1) => {
  135    135   
                    builder.config_snapshot_delivery_info = Some(crate::types::ConfigExportDeliveryInfo::deserialize(deser)?);
  136    136   
                }
  137    137   
                Some(2) => {
  138    138   
                    builder.config_history_delivery_info = Some(crate::types::ConfigExportDeliveryInfo::deserialize(deser)?);
  139    139   
                }
  140    140   
                Some(3) => {
  141    141   
                    builder.config_stream_delivery_info = Some(crate::types::ConfigStreamDeliveryInfo::deserialize(deser)?);
  142    142   
                }
  143    143   
                _ => {}
  144    144   
            }
  145    145   
            Ok(())
  146    146   
        })?;
  147    147   
        Ok(builder.build())
  148    148   
    }
  149    149   
}
         150  +
impl DeliveryChannelStatus {
         151  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         152  +
    pub fn deserialize_with_response(
         153  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         154  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         155  +
        _status: u16,
         156  +
        _body: &[u8],
         157  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         158  +
        Self::deserialize(deserializer)
         159  +
    }
         160  +
}
  150    161   
impl DeliveryChannelStatus {
  151    162   
    /// Creates a new builder-style object to manufacture [`DeliveryChannelStatus`](crate::types::DeliveryChannelStatus).
  152    163   
    pub fn builder() -> crate::types::builders::DeliveryChannelStatusBuilder {
  153    164   
        crate::types::builders::DeliveryChannelStatusBuilder::default()
  154    165   
    }
  155    166   
}
  156    167   
  157    168   
/// A builder for [`DeliveryChannelStatus`](crate::types::DeliveryChannelStatus).
  158    169   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  159    170   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_describe_config_rules_filters.rs

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.configservice",
   19     19   
    "DescribeConfigRulesFilters",
   20     20   
);
   21     21   
static DESCRIBECONFIGRULESFILTERS_MEMBER_EVALUATION_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.configservice#DescribeConfigRulesFilters$EvaluationMode",
   24     24   
        "com.amazonaws.configservice",
   25     25   
        "DescribeConfigRulesFilters",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "evaluation_mode",
          28  +
    "EvaluationMode",
   29     29   
    0,
   30     30   
);
   31     31   
static DESCRIBECONFIGRULESFILTERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    DESCRIBECONFIGRULESFILTERS_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&DESCRIBECONFIGRULESFILTERS_MEMBER_EVALUATION_MODE],
   35     35   
);
   36     36   
impl DescribeConfigRulesFilters {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DESCRIBECONFIGRULESFILTERS_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for DescribeConfigRulesFilters {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.evaluation_mode {
   47     47   
            ser.write_string(&DESCRIBECONFIGRULESFILTERS_MEMBER_EVALUATION_MODE, val.as_str())?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl DescribeConfigRulesFilters {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&DESCRIBECONFIGRULESFILTERS_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&DESCRIBECONFIGRULESFILTERS_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.evaluation_mode = Some(crate::types::EvaluationMode::from(deser.read_string(member)?.as_str()));
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl DescribeConfigRulesFilters {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl DescribeConfigRulesFilters {
   79     90   
    /// Creates a new builder-style object to manufacture [`DescribeConfigRulesFilters`](crate::types::DescribeConfigRulesFilters).
   80     91   
    pub fn builder() -> crate::types::builders::DescribeConfigRulesFiltersBuilder {
   81     92   
        crate::types::builders::DescribeConfigRulesFiltersBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`DescribeConfigRulesFilters`](crate::types::DescribeConfigRulesFilters).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_evaluation.rs

@@ -25,25 +210,224 @@
   45     45   
}
   46     46   
static EVALUATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#Evaluation", "com.amazonaws.configservice", "Evaluation");
   48     48   
static EVALUATION_MEMBER_COMPLIANCE_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.configservice#Evaluation$ComplianceResourceType",
   51     51   
        "com.amazonaws.configservice",
   52     52   
        "Evaluation",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::String,
   55         -
    "compliance_resource_type",
          55  +
    "ComplianceResourceType",
   56     56   
    0,
   57     57   
);
   58     58   
static EVALUATION_MEMBER_COMPLIANCE_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.configservice#Evaluation$ComplianceResourceId",
   61     61   
        "com.amazonaws.configservice",
   62     62   
        "Evaluation",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "compliance_resource_id",
          65  +
    "ComplianceResourceId",
   66     66   
    1,
   67     67   
);
   68     68   
static EVALUATION_MEMBER_COMPLIANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.configservice#Evaluation$ComplianceType",
   71     71   
        "com.amazonaws.configservice",
   72     72   
        "Evaluation",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "compliance_type",
          75  +
    "ComplianceType",
   76     76   
    2,
   77     77   
);
   78     78   
static EVALUATION_MEMBER_ANNOTATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.configservice#Evaluation$Annotation",
   81     81   
        "com.amazonaws.configservice",
   82     82   
        "Evaluation",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "annotation",
          85  +
    "Annotation",
   86     86   
    3,
   87     87   
);
   88     88   
static EVALUATION_MEMBER_ORDERING_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.configservice#Evaluation$OrderingTimestamp",
   91     91   
        "com.amazonaws.configservice",
   92     92   
        "Evaluation",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::Timestamp,
   95         -
    "ordering_timestamp",
          95  +
    "OrderingTimestamp",
   96     96   
    4,
   97     97   
);
   98     98   
static EVALUATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   99     99   
    EVALUATION_SCHEMA_ID,
  100    100   
    ::aws_smithy_schema::ShapeType::Structure,
  101    101   
    &[
  102    102   
        &EVALUATION_MEMBER_COMPLIANCE_RESOURCE_TYPE,
  103    103   
        &EVALUATION_MEMBER_COMPLIANCE_RESOURCE_ID,
  104    104   
        &EVALUATION_MEMBER_COMPLIANCE_TYPE,
  105    105   
        &EVALUATION_MEMBER_ANNOTATION,
  106    106   
        &EVALUATION_MEMBER_ORDERING_TIMESTAMP,
  107    107   
    ],
  108    108   
);
  109    109   
impl Evaluation {
  110    110   
    /// The schema for this shape.
  111    111   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EVALUATION_SCHEMA;
  112    112   
}
  113    113   
impl ::aws_smithy_schema::serde::SerializableStruct for Evaluation {
  114    114   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  115    115   
    fn serialize_members(
  116    116   
        &self,
  117    117   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  118    118   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        {
  120    120   
            let val = &self.compliance_resource_type;
  121    121   
            ser.write_string(&EVALUATION_MEMBER_COMPLIANCE_RESOURCE_TYPE, val)?;
  122    122   
        }
  123    123   
        {
  124    124   
            let val = &self.compliance_resource_id;
  125    125   
            ser.write_string(&EVALUATION_MEMBER_COMPLIANCE_RESOURCE_ID, val)?;
  126    126   
        }
  127    127   
        {
  128    128   
            let val = &self.compliance_type;
  129    129   
            ser.write_string(&EVALUATION_MEMBER_COMPLIANCE_TYPE, val.as_str())?;
  130    130   
        }
  131    131   
        if let Some(ref val) = self.annotation {
  132    132   
            ser.write_string(&EVALUATION_MEMBER_ANNOTATION, val)?;
  133    133   
        }
  134    134   
        {
  135    135   
            let val = &self.ordering_timestamp;
  136    136   
            ser.write_timestamp(&EVALUATION_MEMBER_ORDERING_TIMESTAMP, val)?;
  137    137   
        }
  138    138   
        Ok(())
  139    139   
    }
  140    140   
}
  141    141   
impl Evaluation {
  142    142   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  143         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  144         -
        deserializer: &mut D,
         143  +
    pub fn deserialize(
         144  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  145    145   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  146    146   
        #[allow(unused_variables, unused_mut)]
  147    147   
        let mut builder = Self::builder();
  148    148   
        #[allow(
  149    149   
            unused_variables,
  150    150   
            unreachable_code,
  151    151   
            clippy::single_match,
  152    152   
            clippy::match_single_binding,
  153    153   
            clippy::diverging_sub_expression
  154    154   
        )]
  155         -
        deserializer.read_struct(&EVALUATION_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&EVALUATION_SCHEMA, &mut |member, deser| {
  156    156   
            match member.member_index() {
  157    157   
                Some(0) => {
  158    158   
                    builder.compliance_resource_type = Some(deser.read_string(member)?);
  159    159   
                }
  160    160   
                Some(1) => {
  161    161   
                    builder.compliance_resource_id = Some(deser.read_string(member)?);
  162    162   
                }
  163    163   
                Some(2) => {
  164    164   
                    builder.compliance_type = Some(crate::types::ComplianceType::from(deser.read_string(member)?.as_str()));
  165    165   
                }
  166    166   
                Some(3) => {
  167    167   
                    builder.annotation = Some(deser.read_string(member)?);
  168    168   
                }
  169    169   
                Some(4) => {
  170    170   
                    builder.ordering_timestamp = Some(deser.read_timestamp(member)?);
  171    171   
                }
  172    172   
                _ => {}
  173    173   
            }
  174    174   
            Ok(())
  175    175   
        })?;
         176  +
        builder.compliance_resource_type = builder.compliance_resource_type.or(Some(String::new()));
         177  +
        builder.compliance_resource_id = builder.compliance_resource_id.or(Some(String::new()));
         178  +
        builder.ordering_timestamp = builder.ordering_timestamp.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  176    179   
        builder
  177    180   
            .build()
  178    181   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  179    182   
    }
  180    183   
}
         184  +
impl Evaluation {
         185  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         186  +
    pub fn deserialize_with_response(
         187  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         188  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         189  +
        _status: u16,
         190  +
        _body: &[u8],
         191  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         192  +
        Self::deserialize(deserializer)
         193  +
    }
         194  +
}
  181    195   
impl Evaluation {
  182    196   
    /// Creates a new builder-style object to manufacture [`Evaluation`](crate::types::Evaluation).
  183    197   
    pub fn builder() -> crate::types::builders::EvaluationBuilder {
  184    198   
        crate::types::builders::EvaluationBuilder::default()
  185    199   
    }
  186    200   
}
  187    201   
  188    202   
/// A builder for [`Evaluation`](crate::types::Evaluation).
  189    203   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  190    204   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_evaluation_context.rs

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.configservice",
   19     19   
    "EvaluationContext",
   20     20   
);
   21     21   
static EVALUATIONCONTEXT_MEMBER_EVALUATION_CONTEXT_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.configservice#EvaluationContext$EvaluationContextIdentifier",
   24     24   
        "com.amazonaws.configservice",
   25     25   
        "EvaluationContext",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "evaluation_context_identifier",
          28  +
    "EvaluationContextIdentifier",
   29     29   
    0,
   30     30   
);
   31     31   
static EVALUATIONCONTEXT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    EVALUATIONCONTEXT_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&EVALUATIONCONTEXT_MEMBER_EVALUATION_CONTEXT_IDENTIFIER],
   35     35   
);
   36     36   
impl EvaluationContext {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EVALUATIONCONTEXT_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for EvaluationContext {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.evaluation_context_identifier {
   47     47   
            ser.write_string(&EVALUATIONCONTEXT_MEMBER_EVALUATION_CONTEXT_IDENTIFIER, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl EvaluationContext {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&EVALUATIONCONTEXT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&EVALUATIONCONTEXT_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.evaluation_context_identifier = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl EvaluationContext {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl EvaluationContext {
   79     90   
    /// Creates a new builder-style object to manufacture [`EvaluationContext`](crate::types::EvaluationContext).
   80     91   
    pub fn builder() -> crate::types::builders::EvaluationContextBuilder {
   81     92   
        crate::types::builders::EvaluationContextBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`EvaluationContext`](crate::types::EvaluationContext).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_evaluation_mode_configuration.rs

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.configservice",
   19     19   
    "EvaluationModeConfiguration",
   20     20   
);
   21     21   
static EVALUATIONMODECONFIGURATION_MEMBER_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.configservice#EvaluationModeConfiguration$Mode",
   24     24   
        "com.amazonaws.configservice",
   25     25   
        "EvaluationModeConfiguration",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::String,
   28         -
    "mode",
          28  +
    "Mode",
   29     29   
    0,
   30     30   
);
   31     31   
static EVALUATIONMODECONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    EVALUATIONMODECONFIGURATION_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&EVALUATIONMODECONFIGURATION_MEMBER_MODE],
   35     35   
);
   36     36   
impl EvaluationModeConfiguration {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EVALUATIONMODECONFIGURATION_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for EvaluationModeConfiguration {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.mode {
   47     47   
            ser.write_string(&EVALUATIONMODECONFIGURATION_MEMBER_MODE, val.as_str())?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl EvaluationModeConfiguration {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&EVALUATIONMODECONFIGURATION_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&EVALUATIONMODECONFIGURATION_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.mode = Some(crate::types::EvaluationMode::from(deser.read_string(member)?.as_str()));
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl EvaluationModeConfiguration {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl EvaluationModeConfiguration {
   79     90   
    /// Creates a new builder-style object to manufacture [`EvaluationModeConfiguration`](crate::types::EvaluationModeConfiguration).
   80     91   
    pub fn builder() -> crate::types::builders::EvaluationModeConfigurationBuilder {
   81     92   
        crate::types::builders::EvaluationModeConfigurationBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`EvaluationModeConfiguration`](crate::types::EvaluationModeConfiguration).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_evaluation_result.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_evaluation_result_identifier.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_evaluation_result_qualifier.rs

@@ -16,16 +178,189 @@
   36     36   
    "com.amazonaws.configservice",
   37     37   
    "EvaluationResultQualifier",
   38     38   
);
   39     39   
static EVALUATIONRESULTQUALIFIER_MEMBER_CONFIG_RULE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.configservice#EvaluationResultQualifier$ConfigRuleName",
   42     42   
        "com.amazonaws.configservice",
   43     43   
        "EvaluationResultQualifier",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "config_rule_name",
          46  +
    "ConfigRuleName",
   47     47   
    0,
   48     48   
);
   49     49   
static EVALUATIONRESULTQUALIFIER_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.configservice#EvaluationResultQualifier$ResourceType",
   52     52   
        "com.amazonaws.configservice",
   53     53   
        "EvaluationResultQualifier",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "resource_type",
          56  +
    "ResourceType",
   57     57   
    1,
   58     58   
);
   59     59   
static EVALUATIONRESULTQUALIFIER_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.configservice#EvaluationResultQualifier$ResourceId",
   62     62   
        "com.amazonaws.configservice",
   63     63   
        "EvaluationResultQualifier",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "resource_id",
          66  +
    "ResourceId",
   67     67   
    2,
   68     68   
);
   69     69   
static EVALUATIONRESULTQUALIFIER_MEMBER_EVALUATION_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.configservice#EvaluationResultQualifier$EvaluationMode",
   72     72   
        "com.amazonaws.configservice",
   73     73   
        "EvaluationResultQualifier",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "evaluation_mode",
          76  +
    "EvaluationMode",
   77     77   
    3,
   78     78   
);
   79     79   
static EVALUATIONRESULTQUALIFIER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    EVALUATIONRESULTQUALIFIER_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &EVALUATIONRESULTQUALIFIER_MEMBER_CONFIG_RULE_NAME,
   84     84   
        &EVALUATIONRESULTQUALIFIER_MEMBER_RESOURCE_TYPE,
   85     85   
        &EVALUATIONRESULTQUALIFIER_MEMBER_RESOURCE_ID,
   86     86   
        &EVALUATIONRESULTQUALIFIER_MEMBER_EVALUATION_MODE,
   87     87   
    ],
   88     88   
);
   89     89   
impl EvaluationResultQualifier {
   90     90   
    /// The schema for this shape.
   91     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EVALUATIONRESULTQUALIFIER_SCHEMA;
   92     92   
}
   93     93   
impl ::aws_smithy_schema::serde::SerializableStruct for EvaluationResultQualifier {
   94     94   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   95     95   
    fn serialize_members(
   96     96   
        &self,
   97     97   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   98     98   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        if let Some(ref val) = self.config_rule_name {
  100    100   
            ser.write_string(&EVALUATIONRESULTQUALIFIER_MEMBER_CONFIG_RULE_NAME, val)?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.resource_type {
  103    103   
            ser.write_string(&EVALUATIONRESULTQUALIFIER_MEMBER_RESOURCE_TYPE, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.resource_id {
  106    106   
            ser.write_string(&EVALUATIONRESULTQUALIFIER_MEMBER_RESOURCE_ID, val)?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.evaluation_mode {
  109    109   
            ser.write_string(&EVALUATIONRESULTQUALIFIER_MEMBER_EVALUATION_MODE, val.as_str())?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl EvaluationResultQualifier {
  115    115   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  116         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  117         -
        deserializer: &mut D,
         116  +
    pub fn deserialize(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  118    118   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        #[allow(unused_variables, unused_mut)]
  120    120   
        let mut builder = Self::builder();
  121    121   
        #[allow(
  122    122   
            unused_variables,
  123    123   
            unreachable_code,
  124    124   
            clippy::single_match,
  125    125   
            clippy::match_single_binding,
  126    126   
            clippy::diverging_sub_expression
  127    127   
        )]
  128         -
        deserializer.read_struct(&EVALUATIONRESULTQUALIFIER_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&EVALUATIONRESULTQUALIFIER_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.config_rule_name = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(1) => {
  134    134   
                    builder.resource_type = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(2) => {
  137    137   
                    builder.resource_id = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                Some(3) => {
  140    140   
                    builder.evaluation_mode = Some(crate::types::EvaluationMode::from(deser.read_string(member)?.as_str()));
  141    141   
                }
  142    142   
                _ => {}
  143    143   
            }
  144    144   
            Ok(())
  145    145   
        })?;
  146    146   
        Ok(builder.build())
  147    147   
    }
  148    148   
}
         149  +
impl EvaluationResultQualifier {
         150  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         151  +
    pub fn deserialize_with_response(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         153  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         154  +
        _status: u16,
         155  +
        _body: &[u8],
         156  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         157  +
        Self::deserialize(deserializer)
         158  +
    }
         159  +
}
  149    160   
impl EvaluationResultQualifier {
  150    161   
    /// Creates a new builder-style object to manufacture [`EvaluationResultQualifier`](crate::types::EvaluationResultQualifier).
  151    162   
    pub fn builder() -> crate::types::builders::EvaluationResultQualifierBuilder {
  152    163   
        crate::types::builders::EvaluationResultQualifierBuilder::default()
  153    164   
    }
  154    165   
}
  155    166   
  156    167   
/// A builder for [`EvaluationResultQualifier`](crate::types::EvaluationResultQualifier).
  157    168   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  158    169   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_evaluation_status.rs

@@ -4,4 +132,143 @@
   24     24   
    "com.amazonaws.configservice",
   25     25   
    "EvaluationStatus",
   26     26   
);
   27     27   
static EVALUATIONSTATUS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.configservice#EvaluationStatus$Status",
   30     30   
        "com.amazonaws.configservice",
   31     31   
        "EvaluationStatus",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "status",
          34  +
    "Status",
   35     35   
    0,
   36     36   
);
   37     37   
static EVALUATIONSTATUS_MEMBER_FAILURE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.configservice#EvaluationStatus$FailureReason",
   40     40   
        "com.amazonaws.configservice",
   41     41   
        "EvaluationStatus",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "failure_reason",
          44  +
    "FailureReason",
   45     45   
    1,
   46     46   
);
   47     47   
static EVALUATIONSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    EVALUATIONSTATUS_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&EVALUATIONSTATUS_MEMBER_STATUS, &EVALUATIONSTATUS_MEMBER_FAILURE_REASON],
   51     51   
);
   52     52   
impl EvaluationStatus {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EVALUATIONSTATUS_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for EvaluationStatus {
   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.status;
   64     64   
            ser.write_string(&EVALUATIONSTATUS_MEMBER_STATUS, val.as_str())?;
   65     65   
        }
   66     66   
        if let Some(ref val) = self.failure_reason {
   67     67   
            ser.write_string(&EVALUATIONSTATUS_MEMBER_FAILURE_REASON, val)?;
   68     68   
        }
   69     69   
        Ok(())
   70     70   
    }
   71     71   
}
   72     72   
impl EvaluationStatus {
   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(&EVALUATIONSTATUS_SCHEMA, (), |_, member, deser| {
          86  +
        deserializer.read_struct(&EVALUATIONSTATUS_SCHEMA, &mut |member, deser| {
   87     87   
            match member.member_index() {
   88     88   
                Some(0) => {
   89     89   
                    builder.status = Some(crate::types::ResourceEvaluationStatus::from(deser.read_string(member)?.as_str()));
   90     90   
                }
   91     91   
                Some(1) => {
   92     92   
                    builder.failure_reason = Some(deser.read_string(member)?);
   93     93   
                }
   94     94   
                _ => {}
   95     95   
            }
   96     96   
            Ok(())
   97     97   
        })?;
   98     98   
        builder
   99     99   
            .build()
  100    100   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  101    101   
    }
  102    102   
}
         103  +
impl EvaluationStatus {
         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 EvaluationStatus {
  104    115   
    /// Creates a new builder-style object to manufacture [`EvaluationStatus`](crate::types::EvaluationStatus).
  105    116   
    pub fn builder() -> crate::types::builders::EvaluationStatusBuilder {
  106    117   
        crate::types::builders::EvaluationStatusBuilder::default()
  107    118   
    }
  108    119   
}
  109    120   
  110    121   
/// A builder for [`EvaluationStatus`](crate::types::EvaluationStatus).
  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/config/src/types/_exclusion_by_resource_types.rs

@@ -8,8 +135,143 @@
   28     28   
    "com.amazonaws.configservice",
   29     29   
    "ExclusionByResourceTypes",
   30     30   
);
   31     31   
static EXCLUSIONBYRESOURCETYPES_MEMBER_RESOURCE_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "com.amazonaws.configservice#ExclusionByResourceTypes$resourceTypes",
   34     34   
        "com.amazonaws.configservice",
   35     35   
        "ExclusionByResourceTypes",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::List,
   38         -
    "resource_types",
          38  +
    "resourceTypes",
   39     39   
    0,
   40     40   
);
   41     41   
static EXCLUSIONBYRESOURCETYPES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   42     42   
    EXCLUSIONBYRESOURCETYPES_SCHEMA_ID,
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44     44   
    &[&EXCLUSIONBYRESOURCETYPES_MEMBER_RESOURCE_TYPES],
   45     45   
);
   46     46   
impl ExclusionByResourceTypes {
   47     47   
    /// The schema for this shape.
   48     48   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXCLUSIONBYRESOURCETYPES_SCHEMA;
   49     49   
}
   50     50   
impl ::aws_smithy_schema::serde::SerializableStruct for ExclusionByResourceTypes {
   51     51   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   52     52   
    fn serialize_members(
   53     53   
        &self,
   54     54   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   55     55   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        if let Some(ref val) = self.resource_types {
   57     57   
            ser.write_list(
   58     58   
                &EXCLUSIONBYRESOURCETYPES_MEMBER_RESOURCE_TYPES,
   59     59   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   60     60   
                    for item in val {
   61     61   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
   62     62   
                    }
   63     63   
                    Ok(())
   64     64   
                },
   65     65   
            )?;
   66     66   
        }
   67     67   
        Ok(())
   68     68   
    }
   69     69   
}
   70     70   
impl ExclusionByResourceTypes {
   71     71   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   72         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   73         -
        deserializer: &mut D,
          72  +
    pub fn deserialize(
          73  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   74     74   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   75     75   
        #[allow(unused_variables, unused_mut)]
   76     76   
        let mut builder = Self::builder();
   77     77   
        #[allow(
   78     78   
            unused_variables,
   79     79   
            unreachable_code,
   80     80   
            clippy::single_match,
   81     81   
            clippy::match_single_binding,
   82     82   
            clippy::diverging_sub_expression
   83     83   
        )]
   84         -
        deserializer.read_struct(&EXCLUSIONBYRESOURCETYPES_SCHEMA, (), |_, member, deser| {
          84  +
        deserializer.read_struct(&EXCLUSIONBYRESOURCETYPES_SCHEMA, &mut |member, deser| {
   85     85   
            match member.member_index() {
   86     86   
                Some(0) => {
   87     87   
                    builder.resource_types = Some({
   88         -
                        let container = if let Some(cap) = deser.container_size() {
   89         -
                            Vec::with_capacity(cap)
   90         -
                        } else {
   91         -
                            Vec::new()
   92         -
                        };
   93         -
                        deser.read_list(member, container, |mut list, deser| {
   94         -
                            list.push(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
   95         -
                            Ok(list)
   96         -
                        })?
          88  +
                        let mut container = Vec::new();
          89  +
                        deser.read_list(member, &mut |deser| {
          90  +
                            container.push(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
          91  +
                            Ok(())
          92  +
                        })?;
          93  +
                        container
   97     94   
                    });
   98     95   
                }
   99     96   
                _ => {}
  100     97   
            }
  101     98   
            Ok(())
  102     99   
        })?;
  103    100   
        Ok(builder.build())
  104    101   
    }
  105    102   
}
         103  +
impl ExclusionByResourceTypes {
         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  +
}
  106    114   
impl ExclusionByResourceTypes {
  107    115   
    /// Creates a new builder-style object to manufacture [`ExclusionByResourceTypes`](crate::types::ExclusionByResourceTypes).
  108    116   
    pub fn builder() -> crate::types::builders::ExclusionByResourceTypesBuilder {
  109    117   
        crate::types::builders::ExclusionByResourceTypesBuilder::default()
  110    118   
    }
  111    119   
}
  112    120   
  113    121   
/// A builder for [`ExclusionByResourceTypes`](crate::types::ExclusionByResourceTypes).
  114    122   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  115    123   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_execution_controls.rs

@@ -1,1 +107,118 @@
   18     18   
    "com.amazonaws.configservice",
   19     19   
    "ExecutionControls",
   20     20   
);
   21     21   
static EXECUTIONCONTROLS_MEMBER_SSM_CONTROLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   22     22   
    ::aws_smithy_schema::ShapeId::from_static(
   23     23   
        "com.amazonaws.configservice#ExecutionControls$SsmControls",
   24     24   
        "com.amazonaws.configservice",
   25     25   
        "ExecutionControls",
   26     26   
    ),
   27     27   
    ::aws_smithy_schema::ShapeType::Structure,
   28         -
    "ssm_controls",
          28  +
    "SsmControls",
   29     29   
    0,
   30     30   
);
   31     31   
static EXECUTIONCONTROLS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   32     32   
    EXECUTIONCONTROLS_SCHEMA_ID,
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34     34   
    &[&EXECUTIONCONTROLS_MEMBER_SSM_CONTROLS],
   35     35   
);
   36     36   
impl ExecutionControls {
   37     37   
    /// The schema for this shape.
   38     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXECUTIONCONTROLS_SCHEMA;
   39     39   
}
   40     40   
impl ::aws_smithy_schema::serde::SerializableStruct for ExecutionControls {
   41     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   42     42   
    fn serialize_members(
   43     43   
        &self,
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.ssm_controls {
   47     47   
            ser.write_struct(&EXECUTIONCONTROLS_MEMBER_SSM_CONTROLS, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl ExecutionControls {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&EXECUTIONCONTROLS_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&EXECUTIONCONTROLS_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.ssm_controls = Some(crate::types::SsmControls::deserialize(deser)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl ExecutionControls {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl ExecutionControls {
   79     90   
    /// Creates a new builder-style object to manufacture [`ExecutionControls`](crate::types::ExecutionControls).
   80     91   
    pub fn builder() -> crate::types::builders::ExecutionControlsBuilder {
   81     92   
        crate::types::builders::ExecutionControlsBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`ExecutionControls`](crate::types::ExecutionControls).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_external_evaluation.rs

@@ -24,24 +209,223 @@
   44     44   
    "com.amazonaws.configservice",
   45     45   
    "ExternalEvaluation",
   46     46   
);
   47     47   
static EXTERNALEVALUATION_MEMBER_COMPLIANCE_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.configservice#ExternalEvaluation$ComplianceResourceType",
   50     50   
        "com.amazonaws.configservice",
   51     51   
        "ExternalEvaluation",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::String,
   54         -
    "compliance_resource_type",
          54  +
    "ComplianceResourceType",
   55     55   
    0,
   56     56   
);
   57     57   
static EXTERNALEVALUATION_MEMBER_COMPLIANCE_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.configservice#ExternalEvaluation$ComplianceResourceId",
   60     60   
        "com.amazonaws.configservice",
   61     61   
        "ExternalEvaluation",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "compliance_resource_id",
          64  +
    "ComplianceResourceId",
   65     65   
    1,
   66     66   
);
   67     67   
static EXTERNALEVALUATION_MEMBER_COMPLIANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.configservice#ExternalEvaluation$ComplianceType",
   70     70   
        "com.amazonaws.configservice",
   71     71   
        "ExternalEvaluation",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "compliance_type",
          74  +
    "ComplianceType",
   75     75   
    2,
   76     76   
);
   77     77   
static EXTERNALEVALUATION_MEMBER_ANNOTATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.configservice#ExternalEvaluation$Annotation",
   80     80   
        "com.amazonaws.configservice",
   81     81   
        "ExternalEvaluation",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "annotation",
          84  +
    "Annotation",
   85     85   
    3,
   86     86   
);
   87     87   
static EXTERNALEVALUATION_MEMBER_ORDERING_TIMESTAMP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.configservice#ExternalEvaluation$OrderingTimestamp",
   90     90   
        "com.amazonaws.configservice",
   91     91   
        "ExternalEvaluation",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::Timestamp,
   94         -
    "ordering_timestamp",
          94  +
    "OrderingTimestamp",
   95     95   
    4,
   96     96   
);
   97     97   
static EXTERNALEVALUATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   98     98   
    EXTERNALEVALUATION_SCHEMA_ID,
   99     99   
    ::aws_smithy_schema::ShapeType::Structure,
  100    100   
    &[
  101    101   
        &EXTERNALEVALUATION_MEMBER_COMPLIANCE_RESOURCE_TYPE,
  102    102   
        &EXTERNALEVALUATION_MEMBER_COMPLIANCE_RESOURCE_ID,
  103    103   
        &EXTERNALEVALUATION_MEMBER_COMPLIANCE_TYPE,
  104    104   
        &EXTERNALEVALUATION_MEMBER_ANNOTATION,
  105    105   
        &EXTERNALEVALUATION_MEMBER_ORDERING_TIMESTAMP,
  106    106   
    ],
  107    107   
);
  108    108   
impl ExternalEvaluation {
  109    109   
    /// The schema for this shape.
  110    110   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &EXTERNALEVALUATION_SCHEMA;
  111    111   
}
  112    112   
impl ::aws_smithy_schema::serde::SerializableStruct for ExternalEvaluation {
  113    113   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  114    114   
    fn serialize_members(
  115    115   
        &self,
  116    116   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  117    117   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  118    118   
        {
  119    119   
            let val = &self.compliance_resource_type;
  120    120   
            ser.write_string(&EXTERNALEVALUATION_MEMBER_COMPLIANCE_RESOURCE_TYPE, val)?;
  121    121   
        }
  122    122   
        {
  123    123   
            let val = &self.compliance_resource_id;
  124    124   
            ser.write_string(&EXTERNALEVALUATION_MEMBER_COMPLIANCE_RESOURCE_ID, val)?;
  125    125   
        }
  126    126   
        {
  127    127   
            let val = &self.compliance_type;
  128    128   
            ser.write_string(&EXTERNALEVALUATION_MEMBER_COMPLIANCE_TYPE, val.as_str())?;
  129    129   
        }
  130    130   
        if let Some(ref val) = self.annotation {
  131    131   
            ser.write_string(&EXTERNALEVALUATION_MEMBER_ANNOTATION, val)?;
  132    132   
        }
  133    133   
        {
  134    134   
            let val = &self.ordering_timestamp;
  135    135   
            ser.write_timestamp(&EXTERNALEVALUATION_MEMBER_ORDERING_TIMESTAMP, val)?;
  136    136   
        }
  137    137   
        Ok(())
  138    138   
    }
  139    139   
}
  140    140   
impl ExternalEvaluation {
  141    141   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  142         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  143         -
        deserializer: &mut D,
         142  +
    pub fn deserialize(
         143  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  144    144   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  145    145   
        #[allow(unused_variables, unused_mut)]
  146    146   
        let mut builder = Self::builder();
  147    147   
        #[allow(
  148    148   
            unused_variables,
  149    149   
            unreachable_code,
  150    150   
            clippy::single_match,
  151    151   
            clippy::match_single_binding,
  152    152   
            clippy::diverging_sub_expression
  153    153   
        )]
  154         -
        deserializer.read_struct(&EXTERNALEVALUATION_SCHEMA, (), |_, member, deser| {
         154  +
        deserializer.read_struct(&EXTERNALEVALUATION_SCHEMA, &mut |member, deser| {
  155    155   
            match member.member_index() {
  156    156   
                Some(0) => {
  157    157   
                    builder.compliance_resource_type = Some(deser.read_string(member)?);
  158    158   
                }
  159    159   
                Some(1) => {
  160    160   
                    builder.compliance_resource_id = Some(deser.read_string(member)?);
  161    161   
                }
  162    162   
                Some(2) => {
  163    163   
                    builder.compliance_type = Some(crate::types::ComplianceType::from(deser.read_string(member)?.as_str()));
  164    164   
                }
  165    165   
                Some(3) => {
  166    166   
                    builder.annotation = Some(deser.read_string(member)?);
  167    167   
                }
  168    168   
                Some(4) => {
  169    169   
                    builder.ordering_timestamp = Some(deser.read_timestamp(member)?);
  170    170   
                }
  171    171   
                _ => {}
  172    172   
            }
  173    173   
            Ok(())
  174    174   
        })?;
         175  +
        builder.compliance_resource_type = builder.compliance_resource_type.or(Some(String::new()));
         176  +
        builder.compliance_resource_id = builder.compliance_resource_id.or(Some(String::new()));
         177  +
        builder.ordering_timestamp = builder.ordering_timestamp.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  175    178   
        builder
  176    179   
            .build()
  177    180   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  178    181   
    }
  179    182   
}
         183  +
impl ExternalEvaluation {
         184  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         185  +
    pub fn deserialize_with_response(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         187  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         188  +
        _status: u16,
         189  +
        _body: &[u8],
         190  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         191  +
        Self::deserialize(deserializer)
         192  +
    }
         193  +
}
  180    194   
impl ExternalEvaluation {
  181    195   
    /// Creates a new builder-style object to manufacture [`ExternalEvaluation`](crate::types::ExternalEvaluation).
  182    196   
    pub fn builder() -> crate::types::builders::ExternalEvaluationBuilder {
  183    197   
        crate::types::builders::ExternalEvaluationBuilder::default()
  184    198   
    }
  185    199   
}
  186    200   
  187    201   
/// A builder for [`ExternalEvaluation`](crate::types::ExternalEvaluation).
  188    202   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  189    203   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_failed_delete_remediation_exceptions_batch.rs

@@ -6,6 +152,160 @@
   26     26   
    "com.amazonaws.configservice",
   27     27   
    "FailedDeleteRemediationExceptionsBatch",
   28     28   
);
   29     29   
static FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_MEMBER_FAILURE_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.configservice#FailedDeleteRemediationExceptionsBatch$FailureMessage",
   32     32   
        "com.amazonaws.configservice",
   33     33   
        "FailedDeleteRemediationExceptionsBatch",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "failure_message",
          36  +
    "FailureMessage",
   37     37   
    0,
   38     38   
);
   39     39   
static FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_MEMBER_FAILED_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.configservice#FailedDeleteRemediationExceptionsBatch$FailedItems",
   42     42   
        "com.amazonaws.configservice",
   43     43   
        "FailedDeleteRemediationExceptionsBatch",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46         -
    "failed_items",
          46  +
    "FailedItems",
   47     47   
    1,
   48     48   
);
   49     49   
static FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_MEMBER_FAILURE_MESSAGE,
   54     54   
        &FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_MEMBER_FAILED_ITEMS,
   55     55   
    ],
   56     56   
);
   57     57   
impl FailedDeleteRemediationExceptionsBatch {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for FailedDeleteRemediationExceptionsBatch {
   62     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     63   
    fn serialize_members(
   64     64   
        &self,
   65     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        if let Some(ref val) = self.failure_message {
   68     68   
            ser.write_string(&FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_MEMBER_FAILURE_MESSAGE, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.failed_items {
   71     71   
            ser.write_list(
   72     72   
                &FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_MEMBER_FAILED_ITEMS,
   73     73   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   74     74   
                    for item in val {
   75     75   
                        ser.write_struct(crate::types::RemediationExceptionResourceKey::SCHEMA, item)?;
   76     76   
                    }
   77     77   
                    Ok(())
   78     78   
                },
   79     79   
            )?;
   80     80   
        }
   81     81   
        Ok(())
   82     82   
    }
   83     83   
}
   84     84   
impl FailedDeleteRemediationExceptionsBatch {
   85     85   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   86         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   87         -
        deserializer: &mut D,
          86  +
    pub fn deserialize(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   88     88   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        #[allow(unused_variables, unused_mut)]
   90     90   
        let mut builder = Self::builder();
   91     91   
        #[allow(
   92     92   
            unused_variables,
   93     93   
            unreachable_code,
   94     94   
            clippy::single_match,
   95     95   
            clippy::match_single_binding,
   96     96   
            clippy::diverging_sub_expression
   97     97   
        )]
   98         -
        deserializer.read_struct(&FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_SCHEMA, (), |_, member, deser| {
          98  +
        deserializer.read_struct(&FAILEDDELETEREMEDIATIONEXCEPTIONSBATCH_SCHEMA, &mut |member, deser| {
   99     99   
            match member.member_index() {
  100    100   
                Some(0) => {
  101    101   
                    builder.failure_message = Some(deser.read_string(member)?);
  102    102   
                }
  103    103   
                Some(1) => {
  104    104   
                    builder.failed_items = Some({
  105         -
                        let container = if let Some(cap) = deser.container_size() {
  106         -
                            Vec::with_capacity(cap)
  107         -
                        } else {
  108         -
                            Vec::new()
  109         -
                        };
  110         -
                        deser.read_list(member, container, |mut list, deser| {
  111         -
                            list.push(crate::types::RemediationExceptionResourceKey::deserialize(deser)?);
  112         -
                            Ok(list)
  113         -
                        })?
         105  +
                        let mut container = Vec::new();
         106  +
                        deser.read_list(member, &mut |deser| {
         107  +
                            container.push(crate::types::RemediationExceptionResourceKey::deserialize(deser)?);
         108  +
                            Ok(())
         109  +
                        })?;
         110  +
                        container
  114    111   
                    });
  115    112   
                }
  116    113   
                _ => {}
  117    114   
            }
  118    115   
            Ok(())
  119    116   
        })?;
  120    117   
        Ok(builder.build())
  121    118   
    }
  122    119   
}
         120  +
impl FailedDeleteRemediationExceptionsBatch {
         121  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         122  +
    pub fn deserialize_with_response(
         123  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         124  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         125  +
        _status: u16,
         126  +
        _body: &[u8],
         127  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         128  +
        Self::deserialize(deserializer)
         129  +
    }
         130  +
}
  123    131   
impl FailedDeleteRemediationExceptionsBatch {
  124    132   
    /// Creates a new builder-style object to manufacture [`FailedDeleteRemediationExceptionsBatch`](crate::types::FailedDeleteRemediationExceptionsBatch).
  125    133   
    pub fn builder() -> crate::types::builders::FailedDeleteRemediationExceptionsBatchBuilder {
  126    134   
        crate::types::builders::FailedDeleteRemediationExceptionsBatchBuilder::default()
  127    135   
    }
  128    136   
}
  129    137   
  130    138   
/// A builder for [`FailedDeleteRemediationExceptionsBatch`](crate::types::FailedDeleteRemediationExceptionsBatch).
  131    139   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  132    140   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_failed_remediation_batch.rs

@@ -6,6 +152,160 @@
   26     26   
    "com.amazonaws.configservice",
   27     27   
    "FailedRemediationBatch",
   28     28   
);
   29     29   
static FAILEDREMEDIATIONBATCH_MEMBER_FAILURE_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.configservice#FailedRemediationBatch$FailureMessage",
   32     32   
        "com.amazonaws.configservice",
   33     33   
        "FailedRemediationBatch",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "failure_message",
          36  +
    "FailureMessage",
   37     37   
    0,
   38     38   
);
   39     39   
static FAILEDREMEDIATIONBATCH_MEMBER_FAILED_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.configservice#FailedRemediationBatch$FailedItems",
   42     42   
        "com.amazonaws.configservice",
   43     43   
        "FailedRemediationBatch",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46         -
    "failed_items",
          46  +
    "FailedItems",
   47     47   
    1,
   48     48   
);
   49     49   
static FAILEDREMEDIATIONBATCH_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    FAILEDREMEDIATIONBATCH_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &FAILEDREMEDIATIONBATCH_MEMBER_FAILURE_MESSAGE,
   54     54   
        &FAILEDREMEDIATIONBATCH_MEMBER_FAILED_ITEMS,
   55     55   
    ],
   56     56   
);
   57     57   
impl FailedRemediationBatch {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FAILEDREMEDIATIONBATCH_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for FailedRemediationBatch {
   62     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     63   
    fn serialize_members(
   64     64   
        &self,
   65     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        if let Some(ref val) = self.failure_message {
   68     68   
            ser.write_string(&FAILEDREMEDIATIONBATCH_MEMBER_FAILURE_MESSAGE, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.failed_items {
   71     71   
            ser.write_list(
   72     72   
                &FAILEDREMEDIATIONBATCH_MEMBER_FAILED_ITEMS,
   73     73   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   74     74   
                    for item in val {
   75     75   
                        ser.write_struct(crate::types::RemediationConfiguration::SCHEMA, item)?;
   76     76   
                    }
   77     77   
                    Ok(())
   78     78   
                },
   79     79   
            )?;
   80     80   
        }
   81     81   
        Ok(())
   82     82   
    }
   83     83   
}
   84     84   
impl FailedRemediationBatch {
   85     85   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   86         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   87         -
        deserializer: &mut D,
          86  +
    pub fn deserialize(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   88     88   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        #[allow(unused_variables, unused_mut)]
   90     90   
        let mut builder = Self::builder();
   91     91   
        #[allow(
   92     92   
            unused_variables,
   93     93   
            unreachable_code,
   94     94   
            clippy::single_match,
   95     95   
            clippy::match_single_binding,
   96     96   
            clippy::diverging_sub_expression
   97     97   
        )]
   98         -
        deserializer.read_struct(&FAILEDREMEDIATIONBATCH_SCHEMA, (), |_, member, deser| {
          98  +
        deserializer.read_struct(&FAILEDREMEDIATIONBATCH_SCHEMA, &mut |member, deser| {
   99     99   
            match member.member_index() {
  100    100   
                Some(0) => {
  101    101   
                    builder.failure_message = Some(deser.read_string(member)?);
  102    102   
                }
  103    103   
                Some(1) => {
  104    104   
                    builder.failed_items = Some({
  105         -
                        let container = if let Some(cap) = deser.container_size() {
  106         -
                            Vec::with_capacity(cap)
  107         -
                        } else {
  108         -
                            Vec::new()
  109         -
                        };
  110         -
                        deser.read_list(member, container, |mut list, deser| {
  111         -
                            list.push(crate::types::RemediationConfiguration::deserialize(deser)?);
  112         -
                            Ok(list)
  113         -
                        })?
         105  +
                        let mut container = Vec::new();
         106  +
                        deser.read_list(member, &mut |deser| {
         107  +
                            container.push(crate::types::RemediationConfiguration::deserialize(deser)?);
         108  +
                            Ok(())
         109  +
                        })?;
         110  +
                        container
  114    111   
                    });
  115    112   
                }
  116    113   
                _ => {}
  117    114   
            }
  118    115   
            Ok(())
  119    116   
        })?;
  120    117   
        Ok(builder.build())
  121    118   
    }
  122    119   
}
         120  +
impl FailedRemediationBatch {
         121  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         122  +
    pub fn deserialize_with_response(
         123  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         124  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         125  +
        _status: u16,
         126  +
        _body: &[u8],
         127  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         128  +
        Self::deserialize(deserializer)
         129  +
    }
         130  +
}
  123    131   
impl FailedRemediationBatch {
  124    132   
    /// Creates a new builder-style object to manufacture [`FailedRemediationBatch`](crate::types::FailedRemediationBatch).
  125    133   
    pub fn builder() -> crate::types::builders::FailedRemediationBatchBuilder {
  126    134   
        crate::types::builders::FailedRemediationBatchBuilder::default()
  127    135   
    }
  128    136   
}
  129    137   
  130    138   
/// A builder for [`FailedRemediationBatch`](crate::types::FailedRemediationBatch).
  131    139   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  132    140   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_failed_remediation_exception_batch.rs

@@ -6,6 +152,160 @@
   26     26   
    "com.amazonaws.configservice",
   27     27   
    "FailedRemediationExceptionBatch",
   28     28   
);
   29     29   
static FAILEDREMEDIATIONEXCEPTIONBATCH_MEMBER_FAILURE_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.configservice#FailedRemediationExceptionBatch$FailureMessage",
   32     32   
        "com.amazonaws.configservice",
   33     33   
        "FailedRemediationExceptionBatch",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "failure_message",
          36  +
    "FailureMessage",
   37     37   
    0,
   38     38   
);
   39     39   
static FAILEDREMEDIATIONEXCEPTIONBATCH_MEMBER_FAILED_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.configservice#FailedRemediationExceptionBatch$FailedItems",
   42     42   
        "com.amazonaws.configservice",
   43     43   
        "FailedRemediationExceptionBatch",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46         -
    "failed_items",
          46  +
    "FailedItems",
   47     47   
    1,
   48     48   
);
   49     49   
static FAILEDREMEDIATIONEXCEPTIONBATCH_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    FAILEDREMEDIATIONEXCEPTIONBATCH_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &FAILEDREMEDIATIONEXCEPTIONBATCH_MEMBER_FAILURE_MESSAGE,
   54     54   
        &FAILEDREMEDIATIONEXCEPTIONBATCH_MEMBER_FAILED_ITEMS,
   55     55   
    ],
   56     56   
);
   57     57   
impl FailedRemediationExceptionBatch {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &FAILEDREMEDIATIONEXCEPTIONBATCH_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for FailedRemediationExceptionBatch {
   62     62   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   63     63   
    fn serialize_members(
   64     64   
        &self,
   65     65   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   66     66   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        if let Some(ref val) = self.failure_message {
   68     68   
            ser.write_string(&FAILEDREMEDIATIONEXCEPTIONBATCH_MEMBER_FAILURE_MESSAGE, val)?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.failed_items {
   71     71   
            ser.write_list(
   72     72   
                &FAILEDREMEDIATIONEXCEPTIONBATCH_MEMBER_FAILED_ITEMS,
   73     73   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   74     74   
                    for item in val {
   75     75   
                        ser.write_struct(crate::types::RemediationException::SCHEMA, item)?;
   76     76   
                    }
   77     77   
                    Ok(())
   78     78   
                },
   79     79   
            )?;
   80     80   
        }
   81     81   
        Ok(())
   82     82   
    }
   83     83   
}
   84     84   
impl FailedRemediationExceptionBatch {
   85     85   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   86         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   87         -
        deserializer: &mut D,
          86  +
    pub fn deserialize(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   88     88   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        #[allow(unused_variables, unused_mut)]
   90     90   
        let mut builder = Self::builder();
   91     91   
        #[allow(
   92     92   
            unused_variables,
   93     93   
            unreachable_code,
   94     94   
            clippy::single_match,
   95     95   
            clippy::match_single_binding,
   96     96   
            clippy::diverging_sub_expression
   97     97   
        )]
   98         -
        deserializer.read_struct(&FAILEDREMEDIATIONEXCEPTIONBATCH_SCHEMA, (), |_, member, deser| {
          98  +
        deserializer.read_struct(&FAILEDREMEDIATIONEXCEPTIONBATCH_SCHEMA, &mut |member, deser| {
   99     99   
            match member.member_index() {
  100    100   
                Some(0) => {
  101    101   
                    builder.failure_message = Some(deser.read_string(member)?);
  102    102   
                }
  103    103   
                Some(1) => {
  104    104   
                    builder.failed_items = Some({
  105         -
                        let container = if let Some(cap) = deser.container_size() {
  106         -
                            Vec::with_capacity(cap)
  107         -
                        } else {
  108         -
                            Vec::new()
  109         -
                        };
  110         -
                        deser.read_list(member, container, |mut list, deser| {
  111         -
                            list.push(crate::types::RemediationException::deserialize(deser)?);
  112         -
                            Ok(list)
  113         -
                        })?
         105  +
                        let mut container = Vec::new();
         106  +
                        deser.read_list(member, &mut |deser| {
         107  +
                            container.push(crate::types::RemediationException::deserialize(deser)?);
         108  +
                            Ok(())
         109  +
                        })?;
         110  +
                        container
  114    111   
                    });
  115    112   
                }
  116    113   
                _ => {}
  117    114   
            }
  118    115   
            Ok(())
  119    116   
        })?;
  120    117   
        Ok(builder.build())
  121    118   
    }
  122    119   
}
         120  +
impl FailedRemediationExceptionBatch {
         121  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         122  +
    pub fn deserialize_with_response(
         123  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         124  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         125  +
        _status: u16,
         126  +
        _body: &[u8],
         127  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         128  +
        Self::deserialize(deserializer)
         129  +
    }
         130  +
}
  123    131   
impl FailedRemediationExceptionBatch {
  124    132   
    /// Creates a new builder-style object to manufacture [`FailedRemediationExceptionBatch`](crate::types::FailedRemediationExceptionBatch).
  125    133   
    pub fn builder() -> crate::types::builders::FailedRemediationExceptionBatchBuilder {
  126    134   
        crate::types::builders::FailedRemediationExceptionBatchBuilder::default()
  127    135   
    }
  128    136   
}
  129    137   
  130    138   
/// A builder for [`FailedRemediationExceptionBatch`](crate::types::FailedRemediationExceptionBatch).
  131    139   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  132    140   
#[non_exhaustive]