AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_cluster_service_connect_defaults_request.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_cluster_setting.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container.rs

@@ -95,95 +251,251 @@
  115    115   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.gpu_ids.is_none()`.
  116    116   
    pub fn gpu_ids(&self) -> &[::std::string::String] {
  117    117   
        self.gpu_ids.as_deref().unwrap_or_default()
  118    118   
    }
  119    119   
}
  120    120   
static CONTAINER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  121    121   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container", "com.amazonaws.ecs", "Container");
  122    122   
static CONTAINER_MEMBER_CONTAINER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$containerArn", "com.amazonaws.ecs", "Container"),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "container_arn",
         125  +
    "containerArn",
  126    126   
    0,
  127    127   
);
  128    128   
static CONTAINER_MEMBER_TASK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$taskArn", "com.amazonaws.ecs", "Container"),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "task_arn",
         131  +
    "taskArn",
  132    132   
    1,
  133    133   
);
  134    134   
static CONTAINER_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$name", "com.amazonaws.ecs", "Container"),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137    137   
    "name",
  138    138   
    2,
  139    139   
);
  140    140   
static CONTAINER_MEMBER_IMAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$image", "com.amazonaws.ecs", "Container"),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143    143   
    "image",
  144    144   
    3,
  145    145   
);
  146    146   
static CONTAINER_MEMBER_IMAGE_DIGEST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$imageDigest", "com.amazonaws.ecs", "Container"),
  148    148   
    ::aws_smithy_schema::ShapeType::String,
  149         -
    "image_digest",
         149  +
    "imageDigest",
  150    150   
    4,
  151    151   
);
  152    152   
static CONTAINER_MEMBER_RUNTIME_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$runtimeId", "com.amazonaws.ecs", "Container"),
  154    154   
    ::aws_smithy_schema::ShapeType::String,
  155         -
    "runtime_id",
         155  +
    "runtimeId",
  156    156   
    5,
  157    157   
);
  158    158   
static CONTAINER_MEMBER_LAST_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$lastStatus", "com.amazonaws.ecs", "Container"),
  160    160   
    ::aws_smithy_schema::ShapeType::String,
  161         -
    "last_status",
         161  +
    "lastStatus",
  162    162   
    6,
  163    163   
);
  164    164   
static CONTAINER_MEMBER_EXIT_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$exitCode", "com.amazonaws.ecs", "Container"),
  166    166   
    ::aws_smithy_schema::ShapeType::Integer,
  167         -
    "exit_code",
         167  +
    "exitCode",
  168    168   
    7,
  169    169   
);
  170    170   
static CONTAINER_MEMBER_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  171    171   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$reason", "com.amazonaws.ecs", "Container"),
  172    172   
    ::aws_smithy_schema::ShapeType::String,
  173    173   
    "reason",
  174    174   
    8,
  175    175   
);
  176    176   
static CONTAINER_MEMBER_NETWORK_BINDINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$networkBindings", "com.amazonaws.ecs", "Container"),
  178    178   
    ::aws_smithy_schema::ShapeType::List,
  179         -
    "network_bindings",
         179  +
    "networkBindings",
  180    180   
    9,
  181    181   
);
  182    182   
static CONTAINER_MEMBER_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$networkInterfaces", "com.amazonaws.ecs", "Container"),
  184    184   
    ::aws_smithy_schema::ShapeType::List,
  185         -
    "network_interfaces",
         185  +
    "networkInterfaces",
  186    186   
    10,
  187    187   
);
  188    188   
static CONTAINER_MEMBER_HEALTH_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$healthStatus", "com.amazonaws.ecs", "Container"),
  190    190   
    ::aws_smithy_schema::ShapeType::String,
  191         -
    "health_status",
         191  +
    "healthStatus",
  192    192   
    11,
  193    193   
);
  194    194   
static CONTAINER_MEMBER_MANAGED_AGENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$managedAgents", "com.amazonaws.ecs", "Container"),
  196    196   
    ::aws_smithy_schema::ShapeType::List,
  197         -
    "managed_agents",
         197  +
    "managedAgents",
  198    198   
    12,
  199    199   
);
  200    200   
static CONTAINER_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  201    201   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$cpu", "com.amazonaws.ecs", "Container"),
  202    202   
    ::aws_smithy_schema::ShapeType::String,
  203    203   
    "cpu",
  204    204   
    13,
  205    205   
);
  206    206   
static CONTAINER_MEMBER_MEMORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$memory", "com.amazonaws.ecs", "Container"),
  208    208   
    ::aws_smithy_schema::ShapeType::String,
  209    209   
    "memory",
  210    210   
    14,
  211    211   
);
  212    212   
static CONTAINER_MEMBER_MEMORY_RESERVATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  213    213   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$memoryReservation", "com.amazonaws.ecs", "Container"),
  214    214   
    ::aws_smithy_schema::ShapeType::String,
  215         -
    "memory_reservation",
         215  +
    "memoryReservation",
  216    216   
    15,
  217    217   
);
  218    218   
static CONTAINER_MEMBER_GPU_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  219    219   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Container$gpuIds", "com.amazonaws.ecs", "Container"),
  220    220   
    ::aws_smithy_schema::ShapeType::List,
  221         -
    "gpu_ids",
         221  +
    "gpuIds",
  222    222   
    16,
  223    223   
);
  224    224   
static CONTAINER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  225    225   
    CONTAINER_SCHEMA_ID,
  226    226   
    ::aws_smithy_schema::ShapeType::Structure,
  227    227   
    &[
  228    228   
        &CONTAINER_MEMBER_CONTAINER_ARN,
  229    229   
        &CONTAINER_MEMBER_TASK_ARN,
  230    230   
        &CONTAINER_MEMBER_NAME,
  231    231   
        &CONTAINER_MEMBER_IMAGE,
@@ -312,312 +483,475 @@
  332    332   
                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  333    333   
                }
  334    334   
                Ok(())
  335    335   
            })?;
  336    336   
        }
  337    337   
        Ok(())
  338    338   
    }
  339    339   
}
  340    340   
impl Container {
  341    341   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  342         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  343         -
        deserializer: &mut D,
         342  +
    pub fn deserialize(
         343  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  344    344   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  345    345   
        #[allow(unused_variables, unused_mut)]
  346    346   
        let mut builder = Self::builder();
  347    347   
        #[allow(
  348    348   
            unused_variables,
  349    349   
            unreachable_code,
  350    350   
            clippy::single_match,
  351    351   
            clippy::match_single_binding,
  352    352   
            clippy::diverging_sub_expression
  353    353   
        )]
  354         -
        deserializer.read_struct(&CONTAINER_SCHEMA, (), |_, member, deser| {
         354  +
        deserializer.read_struct(&CONTAINER_SCHEMA, &mut |member, deser| {
  355    355   
            match member.member_index() {
  356    356   
                Some(0) => {
  357    357   
                    builder.container_arn = Some(deser.read_string(member)?);
  358    358   
                }
  359    359   
                Some(1) => {
  360    360   
                    builder.task_arn = Some(deser.read_string(member)?);
  361    361   
                }
  362    362   
                Some(2) => {
  363    363   
                    builder.name = Some(deser.read_string(member)?);
  364    364   
                }
  365    365   
                Some(3) => {
  366    366   
                    builder.image = Some(deser.read_string(member)?);
  367    367   
                }
  368    368   
                Some(4) => {
  369    369   
                    builder.image_digest = Some(deser.read_string(member)?);
  370    370   
                }
  371    371   
                Some(5) => {
  372    372   
                    builder.runtime_id = Some(deser.read_string(member)?);
  373    373   
                }
  374    374   
                Some(6) => {
  375    375   
                    builder.last_status = Some(deser.read_string(member)?);
  376    376   
                }
  377    377   
                Some(7) => {
  378    378   
                    builder.exit_code = Some(deser.read_integer(member)?);
  379    379   
                }
  380    380   
                Some(8) => {
  381    381   
                    builder.reason = Some(deser.read_string(member)?);
  382    382   
                }
  383    383   
                Some(9) => {
  384    384   
                    builder.network_bindings = Some({
  385         -
                        let container = if let Some(cap) = deser.container_size() {
  386         -
                            Vec::with_capacity(cap)
  387         -
                        } else {
  388         -
                            Vec::new()
  389         -
                        };
  390         -
                        deser.read_list(member, container, |mut list, deser| {
  391         -
                            list.push(crate::types::NetworkBinding::deserialize(deser)?);
  392         -
                            Ok(list)
  393         -
                        })?
         385  +
                        let mut container = Vec::new();
         386  +
                        deser.read_list(member, &mut |deser| {
         387  +
                            container.push(crate::types::NetworkBinding::deserialize(deser)?);
         388  +
                            Ok(())
         389  +
                        })?;
         390  +
                        container
  394    391   
                    });
  395    392   
                }
  396    393   
                Some(10) => {
  397    394   
                    builder.network_interfaces = Some({
  398         -
                        let container = if let Some(cap) = deser.container_size() {
  399         -
                            Vec::with_capacity(cap)
  400         -
                        } else {
  401         -
                            Vec::new()
  402         -
                        };
  403         -
                        deser.read_list(member, container, |mut list, deser| {
  404         -
                            list.push(crate::types::NetworkInterface::deserialize(deser)?);
  405         -
                            Ok(list)
  406         -
                        })?
         395  +
                        let mut container = Vec::new();
         396  +
                        deser.read_list(member, &mut |deser| {
         397  +
                            container.push(crate::types::NetworkInterface::deserialize(deser)?);
         398  +
                            Ok(())
         399  +
                        })?;
         400  +
                        container
  407    401   
                    });
  408    402   
                }
  409    403   
                Some(11) => {
  410    404   
                    builder.health_status = Some(crate::types::HealthStatus::from(deser.read_string(member)?.as_str()));
  411    405   
                }
  412    406   
                Some(12) => {
  413    407   
                    builder.managed_agents = Some({
  414         -
                        let container = if let Some(cap) = deser.container_size() {
  415         -
                            Vec::with_capacity(cap)
  416         -
                        } else {
  417         -
                            Vec::new()
  418         -
                        };
  419         -
                        deser.read_list(member, container, |mut list, deser| {
  420         -
                            list.push(crate::types::ManagedAgent::deserialize(deser)?);
  421         -
                            Ok(list)
  422         -
                        })?
         408  +
                        let mut container = Vec::new();
         409  +
                        deser.read_list(member, &mut |deser| {
         410  +
                            container.push(crate::types::ManagedAgent::deserialize(deser)?);
         411  +
                            Ok(())
         412  +
                        })?;
         413  +
                        container
  423    414   
                    });
  424    415   
                }
  425    416   
                Some(13) => {
  426    417   
                    builder.cpu = Some(deser.read_string(member)?);
  427    418   
                }
  428    419   
                Some(14) => {
  429    420   
                    builder.memory = Some(deser.read_string(member)?);
  430    421   
                }
  431    422   
                Some(15) => {
  432    423   
                    builder.memory_reservation = Some(deser.read_string(member)?);
  433    424   
                }
  434    425   
                Some(16) => {
  435         -
                    builder.gpu_ids = Some({
  436         -
                        let container = if let Some(cap) = deser.container_size() {
  437         -
                            Vec::with_capacity(cap)
  438         -
                        } else {
  439         -
                            Vec::new()
  440         -
                        };
  441         -
                        deser.read_list(member, container, |mut list, deser| {
  442         -
                            list.push(deser.read_string(member)?);
  443         -
                            Ok(list)
  444         -
                        })?
  445         -
                    });
         426  +
                    builder.gpu_ids = Some(deser.read_string_list(member)?);
  446    427   
                }
  447    428   
                _ => {}
  448    429   
            }
  449    430   
            Ok(())
  450    431   
        })?;
  451    432   
        Ok(builder.build())
  452    433   
    }
  453    434   
}
         435  +
impl Container {
         436  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         437  +
    pub fn deserialize_with_response(
         438  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         439  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         440  +
        _status: u16,
         441  +
        _body: &[u8],
         442  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         443  +
        Self::deserialize(deserializer)
         444  +
    }
         445  +
}
  454    446   
impl Container {
  455    447   
    /// Creates a new builder-style object to manufacture [`Container`](crate::types::Container).
  456    448   
    pub fn builder() -> crate::types::builders::ContainerBuilder {
  457    449   
        crate::types::builders::ContainerBuilder::default()
  458    450   
    }
  459    451   
}
  460    452   
  461    453   
/// A builder for [`Container`](crate::types::Container).
  462    454   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  463    455   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container_definition.rs

@@ -615,615 +1049,1049 @@
  635    635   
    "image",
  636    636   
    1,
  637    637   
);
  638    638   
static CONTAINERDEFINITION_MEMBER_REPOSITORY_CREDENTIALS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  639    639   
    ::aws_smithy_schema::ShapeId::from_static(
  640    640   
        "com.amazonaws.ecs#ContainerDefinition$repositoryCredentials",
  641    641   
        "com.amazonaws.ecs",
  642    642   
        "ContainerDefinition",
  643    643   
    ),
  644    644   
    ::aws_smithy_schema::ShapeType::Structure,
  645         -
    "repository_credentials",
         645  +
    "repositoryCredentials",
  646    646   
    2,
  647    647   
);
  648    648   
static CONTAINERDEFINITION_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  649    649   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerDefinition$cpu", "com.amazonaws.ecs", "ContainerDefinition"),
  650    650   
    ::aws_smithy_schema::ShapeType::Integer,
  651    651   
    "cpu",
  652    652   
    3,
  653    653   
);
  654    654   
static CONTAINERDEFINITION_MEMBER_MEMORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  655    655   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerDefinition$memory", "com.amazonaws.ecs", "ContainerDefinition"),
  656    656   
    ::aws_smithy_schema::ShapeType::Integer,
  657    657   
    "memory",
  658    658   
    4,
  659    659   
);
  660    660   
static CONTAINERDEFINITION_MEMBER_MEMORY_RESERVATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  661    661   
    ::aws_smithy_schema::ShapeId::from_static(
  662    662   
        "com.amazonaws.ecs#ContainerDefinition$memoryReservation",
  663    663   
        "com.amazonaws.ecs",
  664    664   
        "ContainerDefinition",
  665    665   
    ),
  666    666   
    ::aws_smithy_schema::ShapeType::Integer,
  667         -
    "memory_reservation",
         667  +
    "memoryReservation",
  668    668   
    5,
  669    669   
);
  670    670   
static CONTAINERDEFINITION_MEMBER_LINKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  671    671   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerDefinition$links", "com.amazonaws.ecs", "ContainerDefinition"),
  672    672   
    ::aws_smithy_schema::ShapeType::List,
  673    673   
    "links",
  674    674   
    6,
  675    675   
);
  676    676   
static CONTAINERDEFINITION_MEMBER_PORT_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  677    677   
    ::aws_smithy_schema::ShapeId::from_static(
  678    678   
        "com.amazonaws.ecs#ContainerDefinition$portMappings",
  679    679   
        "com.amazonaws.ecs",
  680    680   
        "ContainerDefinition",
  681    681   
    ),
  682    682   
    ::aws_smithy_schema::ShapeType::List,
  683         -
    "port_mappings",
         683  +
    "portMappings",
  684    684   
    7,
  685    685   
);
  686    686   
static CONTAINERDEFINITION_MEMBER_ESSENTIAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  687    687   
    ::aws_smithy_schema::ShapeId::from_static(
  688    688   
        "com.amazonaws.ecs#ContainerDefinition$essential",
  689    689   
        "com.amazonaws.ecs",
  690    690   
        "ContainerDefinition",
  691    691   
    ),
  692    692   
    ::aws_smithy_schema::ShapeType::Boolean,
  693    693   
    "essential",
  694    694   
    8,
  695    695   
);
  696    696   
static CONTAINERDEFINITION_MEMBER_RESTART_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  697    697   
    ::aws_smithy_schema::ShapeId::from_static(
  698    698   
        "com.amazonaws.ecs#ContainerDefinition$restartPolicy",
  699    699   
        "com.amazonaws.ecs",
  700    700   
        "ContainerDefinition",
  701    701   
    ),
  702    702   
    ::aws_smithy_schema::ShapeType::Structure,
  703         -
    "restart_policy",
         703  +
    "restartPolicy",
  704    704   
    9,
  705    705   
);
  706    706   
static CONTAINERDEFINITION_MEMBER_ENTRY_POINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  707    707   
    ::aws_smithy_schema::ShapeId::from_static(
  708    708   
        "com.amazonaws.ecs#ContainerDefinition$entryPoint",
  709    709   
        "com.amazonaws.ecs",
  710    710   
        "ContainerDefinition",
  711    711   
    ),
  712    712   
    ::aws_smithy_schema::ShapeType::List,
  713         -
    "entry_point",
         713  +
    "entryPoint",
  714    714   
    10,
  715    715   
);
  716    716   
static CONTAINERDEFINITION_MEMBER_COMMAND: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  717    717   
    ::aws_smithy_schema::ShapeId::from_static(
  718    718   
        "com.amazonaws.ecs#ContainerDefinition$command",
  719    719   
        "com.amazonaws.ecs",
  720    720   
        "ContainerDefinition",
  721    721   
    ),
  722    722   
    ::aws_smithy_schema::ShapeType::List,
  723    723   
    "command",
  724    724   
    11,
  725    725   
);
  726    726   
static CONTAINERDEFINITION_MEMBER_ENVIRONMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  727    727   
    ::aws_smithy_schema::ShapeId::from_static(
  728    728   
        "com.amazonaws.ecs#ContainerDefinition$environment",
  729    729   
        "com.amazonaws.ecs",
  730    730   
        "ContainerDefinition",
  731    731   
    ),
  732    732   
    ::aws_smithy_schema::ShapeType::List,
  733    733   
    "environment",
  734    734   
    12,
  735    735   
);
  736    736   
static CONTAINERDEFINITION_MEMBER_ENVIRONMENT_FILES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  737    737   
    ::aws_smithy_schema::ShapeId::from_static(
  738    738   
        "com.amazonaws.ecs#ContainerDefinition$environmentFiles",
  739    739   
        "com.amazonaws.ecs",
  740    740   
        "ContainerDefinition",
  741    741   
    ),
  742    742   
    ::aws_smithy_schema::ShapeType::List,
  743         -
    "environment_files",
         743  +
    "environmentFiles",
  744    744   
    13,
  745    745   
);
  746    746   
static CONTAINERDEFINITION_MEMBER_MOUNT_POINTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  747    747   
    ::aws_smithy_schema::ShapeId::from_static(
  748    748   
        "com.amazonaws.ecs#ContainerDefinition$mountPoints",
  749    749   
        "com.amazonaws.ecs",
  750    750   
        "ContainerDefinition",
  751    751   
    ),
  752    752   
    ::aws_smithy_schema::ShapeType::List,
  753         -
    "mount_points",
         753  +
    "mountPoints",
  754    754   
    14,
  755    755   
);
  756    756   
static CONTAINERDEFINITION_MEMBER_VOLUMES_FROM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  757    757   
    ::aws_smithy_schema::ShapeId::from_static(
  758    758   
        "com.amazonaws.ecs#ContainerDefinition$volumesFrom",
  759    759   
        "com.amazonaws.ecs",
  760    760   
        "ContainerDefinition",
  761    761   
    ),
  762    762   
    ::aws_smithy_schema::ShapeType::List,
  763         -
    "volumes_from",
         763  +
    "volumesFrom",
  764    764   
    15,
  765    765   
);
  766    766   
static CONTAINERDEFINITION_MEMBER_LINUX_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  767    767   
    ::aws_smithy_schema::ShapeId::from_static(
  768    768   
        "com.amazonaws.ecs#ContainerDefinition$linuxParameters",
  769    769   
        "com.amazonaws.ecs",
  770    770   
        "ContainerDefinition",
  771    771   
    ),
  772    772   
    ::aws_smithy_schema::ShapeType::Structure,
  773         -
    "linux_parameters",
         773  +
    "linuxParameters",
  774    774   
    16,
  775    775   
);
  776    776   
static CONTAINERDEFINITION_MEMBER_SECRETS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  777    777   
    ::aws_smithy_schema::ShapeId::from_static(
  778    778   
        "com.amazonaws.ecs#ContainerDefinition$secrets",
  779    779   
        "com.amazonaws.ecs",
  780    780   
        "ContainerDefinition",
  781    781   
    ),
  782    782   
    ::aws_smithy_schema::ShapeType::List,
  783    783   
    "secrets",
  784    784   
    17,
  785    785   
);
  786    786   
static CONTAINERDEFINITION_MEMBER_DEPENDS_ON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  787    787   
    ::aws_smithy_schema::ShapeId::from_static(
  788    788   
        "com.amazonaws.ecs#ContainerDefinition$dependsOn",
  789    789   
        "com.amazonaws.ecs",
  790    790   
        "ContainerDefinition",
  791    791   
    ),
  792    792   
    ::aws_smithy_schema::ShapeType::List,
  793         -
    "depends_on",
         793  +
    "dependsOn",
  794    794   
    18,
  795    795   
);
  796    796   
static CONTAINERDEFINITION_MEMBER_START_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  797    797   
    ::aws_smithy_schema::ShapeId::from_static(
  798    798   
        "com.amazonaws.ecs#ContainerDefinition$startTimeout",
  799    799   
        "com.amazonaws.ecs",
  800    800   
        "ContainerDefinition",
  801    801   
    ),
  802    802   
    ::aws_smithy_schema::ShapeType::Integer,
  803         -
    "start_timeout",
         803  +
    "startTimeout",
  804    804   
    19,
  805    805   
);
  806    806   
static CONTAINERDEFINITION_MEMBER_STOP_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  807    807   
    ::aws_smithy_schema::ShapeId::from_static(
  808    808   
        "com.amazonaws.ecs#ContainerDefinition$stopTimeout",
  809    809   
        "com.amazonaws.ecs",
  810    810   
        "ContainerDefinition",
  811    811   
    ),
  812    812   
    ::aws_smithy_schema::ShapeType::Integer,
  813         -
    "stop_timeout",
         813  +
    "stopTimeout",
  814    814   
    20,
  815    815   
);
  816    816   
static CONTAINERDEFINITION_MEMBER_VERSION_CONSISTENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  817    817   
    ::aws_smithy_schema::ShapeId::from_static(
  818    818   
        "com.amazonaws.ecs#ContainerDefinition$versionConsistency",
  819    819   
        "com.amazonaws.ecs",
  820    820   
        "ContainerDefinition",
  821    821   
    ),
  822    822   
    ::aws_smithy_schema::ShapeType::String,
  823         -
    "version_consistency",
         823  +
    "versionConsistency",
  824    824   
    21,
  825    825   
);
  826    826   
static CONTAINERDEFINITION_MEMBER_HOSTNAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  827    827   
    ::aws_smithy_schema::ShapeId::from_static(
  828    828   
        "com.amazonaws.ecs#ContainerDefinition$hostname",
  829    829   
        "com.amazonaws.ecs",
  830    830   
        "ContainerDefinition",
  831    831   
    ),
  832    832   
    ::aws_smithy_schema::ShapeType::String,
  833    833   
    "hostname",
  834    834   
    22,
  835    835   
);
  836    836   
static CONTAINERDEFINITION_MEMBER_USER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  837    837   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerDefinition$user", "com.amazonaws.ecs", "ContainerDefinition"),
  838    838   
    ::aws_smithy_schema::ShapeType::String,
  839    839   
    "user",
  840    840   
    23,
  841    841   
);
  842    842   
static CONTAINERDEFINITION_MEMBER_WORKING_DIRECTORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  843    843   
    ::aws_smithy_schema::ShapeId::from_static(
  844    844   
        "com.amazonaws.ecs#ContainerDefinition$workingDirectory",
  845    845   
        "com.amazonaws.ecs",
  846    846   
        "ContainerDefinition",
  847    847   
    ),
  848    848   
    ::aws_smithy_schema::ShapeType::String,
  849         -
    "working_directory",
         849  +
    "workingDirectory",
  850    850   
    24,
  851    851   
);
  852    852   
static CONTAINERDEFINITION_MEMBER_DISABLE_NETWORKING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  853    853   
    ::aws_smithy_schema::ShapeId::from_static(
  854    854   
        "com.amazonaws.ecs#ContainerDefinition$disableNetworking",
  855    855   
        "com.amazonaws.ecs",
  856    856   
        "ContainerDefinition",
  857    857   
    ),
  858    858   
    ::aws_smithy_schema::ShapeType::Boolean,
  859         -
    "disable_networking",
         859  +
    "disableNetworking",
  860    860   
    25,
  861    861   
);
  862    862   
static CONTAINERDEFINITION_MEMBER_PRIVILEGED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  863    863   
    ::aws_smithy_schema::ShapeId::from_static(
  864    864   
        "com.amazonaws.ecs#ContainerDefinition$privileged",
  865    865   
        "com.amazonaws.ecs",
  866    866   
        "ContainerDefinition",
  867    867   
    ),
  868    868   
    ::aws_smithy_schema::ShapeType::Boolean,
  869    869   
    "privileged",
  870    870   
    26,
  871    871   
);
  872    872   
static CONTAINERDEFINITION_MEMBER_READONLY_ROOT_FILESYSTEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  873    873   
    ::aws_smithy_schema::ShapeId::from_static(
  874    874   
        "com.amazonaws.ecs#ContainerDefinition$readonlyRootFilesystem",
  875    875   
        "com.amazonaws.ecs",
  876    876   
        "ContainerDefinition",
  877    877   
    ),
  878    878   
    ::aws_smithy_schema::ShapeType::Boolean,
  879         -
    "readonly_root_filesystem",
         879  +
    "readonlyRootFilesystem",
  880    880   
    27,
  881    881   
);
  882    882   
static CONTAINERDEFINITION_MEMBER_DNS_SERVERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  883    883   
    ::aws_smithy_schema::ShapeId::from_static(
  884    884   
        "com.amazonaws.ecs#ContainerDefinition$dnsServers",
  885    885   
        "com.amazonaws.ecs",
  886    886   
        "ContainerDefinition",
  887    887   
    ),
  888    888   
    ::aws_smithy_schema::ShapeType::List,
  889         -
    "dns_servers",
         889  +
    "dnsServers",
  890    890   
    28,
  891    891   
);
  892    892   
static CONTAINERDEFINITION_MEMBER_DNS_SEARCH_DOMAINS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  893    893   
    ::aws_smithy_schema::ShapeId::from_static(
  894    894   
        "com.amazonaws.ecs#ContainerDefinition$dnsSearchDomains",
  895    895   
        "com.amazonaws.ecs",
  896    896   
        "ContainerDefinition",
  897    897   
    ),
  898    898   
    ::aws_smithy_schema::ShapeType::List,
  899         -
    "dns_search_domains",
         899  +
    "dnsSearchDomains",
  900    900   
    29,
  901    901   
);
  902    902   
static CONTAINERDEFINITION_MEMBER_EXTRA_HOSTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  903    903   
    ::aws_smithy_schema::ShapeId::from_static(
  904    904   
        "com.amazonaws.ecs#ContainerDefinition$extraHosts",
  905    905   
        "com.amazonaws.ecs",
  906    906   
        "ContainerDefinition",
  907    907   
    ),
  908    908   
    ::aws_smithy_schema::ShapeType::List,
  909         -
    "extra_hosts",
         909  +
    "extraHosts",
  910    910   
    30,
  911    911   
);
  912    912   
static CONTAINERDEFINITION_MEMBER_DOCKER_SECURITY_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  913    913   
    ::aws_smithy_schema::ShapeId::from_static(
  914    914   
        "com.amazonaws.ecs#ContainerDefinition$dockerSecurityOptions",
  915    915   
        "com.amazonaws.ecs",
  916    916   
        "ContainerDefinition",
  917    917   
    ),
  918    918   
    ::aws_smithy_schema::ShapeType::List,
  919         -
    "docker_security_options",
         919  +
    "dockerSecurityOptions",
  920    920   
    31,
  921    921   
);
  922    922   
static CONTAINERDEFINITION_MEMBER_INTERACTIVE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  923    923   
    ::aws_smithy_schema::ShapeId::from_static(
  924    924   
        "com.amazonaws.ecs#ContainerDefinition$interactive",
  925    925   
        "com.amazonaws.ecs",
  926    926   
        "ContainerDefinition",
  927    927   
    ),
  928    928   
    ::aws_smithy_schema::ShapeType::Boolean,
  929    929   
    "interactive",
  930    930   
    32,
  931    931   
);
  932    932   
static CONTAINERDEFINITION_MEMBER_PSEUDO_TERMINAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  933    933   
    ::aws_smithy_schema::ShapeId::from_static(
  934    934   
        "com.amazonaws.ecs#ContainerDefinition$pseudoTerminal",
  935    935   
        "com.amazonaws.ecs",
  936    936   
        "ContainerDefinition",
  937    937   
    ),
  938    938   
    ::aws_smithy_schema::ShapeType::Boolean,
  939         -
    "pseudo_terminal",
         939  +
    "pseudoTerminal",
  940    940   
    33,
  941    941   
);
  942    942   
static CONTAINERDEFINITION_MEMBER_DOCKER_LABELS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  943    943   
    ::aws_smithy_schema::ShapeId::from_static(
  944    944   
        "com.amazonaws.ecs#ContainerDefinition$dockerLabels",
  945    945   
        "com.amazonaws.ecs",
  946    946   
        "ContainerDefinition",
  947    947   
    ),
  948    948   
    ::aws_smithy_schema::ShapeType::Map,
  949         -
    "docker_labels",
         949  +
    "dockerLabels",
  950    950   
    34,
  951    951   
);
  952    952   
static CONTAINERDEFINITION_MEMBER_ULIMITS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  953    953   
    ::aws_smithy_schema::ShapeId::from_static(
  954    954   
        "com.amazonaws.ecs#ContainerDefinition$ulimits",
  955    955   
        "com.amazonaws.ecs",
  956    956   
        "ContainerDefinition",
  957    957   
    ),
  958    958   
    ::aws_smithy_schema::ShapeType::List,
  959    959   
    "ulimits",
  960    960   
    35,
  961    961   
);
  962    962   
static CONTAINERDEFINITION_MEMBER_LOG_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  963    963   
    ::aws_smithy_schema::ShapeId::from_static(
  964    964   
        "com.amazonaws.ecs#ContainerDefinition$logConfiguration",
  965    965   
        "com.amazonaws.ecs",
  966    966   
        "ContainerDefinition",
  967    967   
    ),
  968    968   
    ::aws_smithy_schema::ShapeType::Structure,
  969         -
    "log_configuration",
         969  +
    "logConfiguration",
  970    970   
    36,
  971    971   
);
  972    972   
static CONTAINERDEFINITION_MEMBER_HEALTH_CHECK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  973    973   
    ::aws_smithy_schema::ShapeId::from_static(
  974    974   
        "com.amazonaws.ecs#ContainerDefinition$healthCheck",
  975    975   
        "com.amazonaws.ecs",
  976    976   
        "ContainerDefinition",
  977    977   
    ),
  978    978   
    ::aws_smithy_schema::ShapeType::Structure,
  979         -
    "health_check",
         979  +
    "healthCheck",
  980    980   
    37,
  981    981   
);
  982    982   
static CONTAINERDEFINITION_MEMBER_SYSTEM_CONTROLS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  983    983   
    ::aws_smithy_schema::ShapeId::from_static(
  984    984   
        "com.amazonaws.ecs#ContainerDefinition$systemControls",
  985    985   
        "com.amazonaws.ecs",
  986    986   
        "ContainerDefinition",
  987    987   
    ),
  988    988   
    ::aws_smithy_schema::ShapeType::List,
  989         -
    "system_controls",
         989  +
    "systemControls",
  990    990   
    38,
  991    991   
);
  992    992   
static CONTAINERDEFINITION_MEMBER_RESOURCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  993    993   
    ::aws_smithy_schema::ShapeId::from_static(
  994    994   
        "com.amazonaws.ecs#ContainerDefinition$resourceRequirements",
  995    995   
        "com.amazonaws.ecs",
  996    996   
        "ContainerDefinition",
  997    997   
    ),
  998    998   
    ::aws_smithy_schema::ShapeType::List,
  999         -
    "resource_requirements",
         999  +
    "resourceRequirements",
 1000   1000   
    39,
 1001   1001   
);
 1002   1002   
static CONTAINERDEFINITION_MEMBER_FIRELENS_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1003   1003   
    ::aws_smithy_schema::ShapeId::from_static(
 1004   1004   
        "com.amazonaws.ecs#ContainerDefinition$firelensConfiguration",
 1005   1005   
        "com.amazonaws.ecs",
 1006   1006   
        "ContainerDefinition",
 1007   1007   
    ),
 1008   1008   
    ::aws_smithy_schema::ShapeType::Structure,
 1009         -
    "firelens_configuration",
        1009  +
    "firelensConfiguration",
 1010   1010   
    40,
 1011   1011   
);
 1012   1012   
static CONTAINERDEFINITION_MEMBER_CREDENTIAL_SPECS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
 1013   1013   
    ::aws_smithy_schema::ShapeId::from_static(
 1014   1014   
        "com.amazonaws.ecs#ContainerDefinition$credentialSpecs",
 1015   1015   
        "com.amazonaws.ecs",
 1016   1016   
        "ContainerDefinition",
 1017   1017   
    ),
 1018   1018   
    ::aws_smithy_schema::ShapeType::List,
 1019         -
    "credential_specs",
        1019  +
    "credentialSpecs",
 1020   1020   
    41,
 1021   1021   
);
 1022   1022   
static CONTAINERDEFINITION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
 1023   1023   
    CONTAINERDEFINITION_SCHEMA_ID,
 1024   1024   
    ::aws_smithy_schema::ShapeType::Structure,
 1025   1025   
    &[
 1026   1026   
        &CONTAINERDEFINITION_MEMBER_NAME,
 1027   1027   
        &CONTAINERDEFINITION_MEMBER_IMAGE,
 1028   1028   
        &CONTAINERDEFINITION_MEMBER_REPOSITORY_CREDENTIALS,
 1029   1029   
        &CONTAINERDEFINITION_MEMBER_CPU,
@@ -1335,1335 +1731,1629 @@
 1355   1355   
                    }
 1356   1356   
                    Ok(())
 1357   1357   
                },
 1358   1358   
            )?;
 1359   1359   
        }
 1360   1360   
        Ok(())
 1361   1361   
    }
 1362   1362   
}
 1363   1363   
impl ContainerDefinition {
 1364   1364   
    /// Deserializes this structure from a [`ShapeDeserializer`].
 1365         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
 1366         -
        deserializer: &mut D,
        1365  +
    pub fn deserialize(
        1366  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
 1367   1367   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
 1368   1368   
        #[allow(unused_variables, unused_mut)]
 1369   1369   
        let mut builder = Self::builder();
 1370   1370   
        #[allow(
 1371   1371   
            unused_variables,
 1372   1372   
            unreachable_code,
 1373   1373   
            clippy::single_match,
 1374   1374   
            clippy::match_single_binding,
 1375   1375   
            clippy::diverging_sub_expression
 1376   1376   
        )]
 1377         -
        deserializer.read_struct(&CONTAINERDEFINITION_SCHEMA, (), |_, member, deser| {
        1377  +
        deserializer.read_struct(&CONTAINERDEFINITION_SCHEMA, &mut |member, deser| {
 1378   1378   
            match member.member_index() {
 1379   1379   
                Some(0) => {
 1380   1380   
                    builder.name = Some(deser.read_string(member)?);
 1381   1381   
                }
 1382   1382   
                Some(1) => {
 1383   1383   
                    builder.image = Some(deser.read_string(member)?);
 1384   1384   
                }
 1385   1385   
                Some(2) => {
 1386   1386   
                    builder.repository_credentials = Some(crate::types::RepositoryCredentials::deserialize(deser)?);
 1387   1387   
                }
 1388   1388   
                Some(3) => {
 1389   1389   
                    builder.cpu = Some(deser.read_integer(member)?);
 1390   1390   
                }
 1391   1391   
                Some(4) => {
 1392   1392   
                    builder.memory = Some(deser.read_integer(member)?);
 1393   1393   
                }
 1394   1394   
                Some(5) => {
 1395   1395   
                    builder.memory_reservation = Some(deser.read_integer(member)?);
 1396   1396   
                }
 1397   1397   
                Some(6) => {
 1398         -
                    builder.links = Some({
 1399         -
                        let container = if let Some(cap) = deser.container_size() {
 1400         -
                            Vec::with_capacity(cap)
 1401         -
                        } else {
 1402         -
                            Vec::new()
 1403         -
                        };
 1404         -
                        deser.read_list(member, container, |mut list, deser| {
 1405         -
                            list.push(deser.read_string(member)?);
 1406         -
                            Ok(list)
 1407         -
                        })?
 1408         -
                    });
        1398  +
                    builder.links = Some(deser.read_string_list(member)?);
 1409   1399   
                }
 1410   1400   
                Some(7) => {
 1411   1401   
                    builder.port_mappings = Some({
 1412         -
                        let container = if let Some(cap) = deser.container_size() {
 1413         -
                            Vec::with_capacity(cap)
 1414         -
                        } else {
 1415         -
                            Vec::new()
 1416         -
                        };
 1417         -
                        deser.read_list(member, container, |mut list, deser| {
 1418         -
                            list.push(crate::types::PortMapping::deserialize(deser)?);
 1419         -
                            Ok(list)
 1420         -
                        })?
        1402  +
                        let mut container = Vec::new();
        1403  +
                        deser.read_list(member, &mut |deser| {
        1404  +
                            container.push(crate::types::PortMapping::deserialize(deser)?);
        1405  +
                            Ok(())
        1406  +
                        })?;
        1407  +
                        container
 1421   1408   
                    });
 1422   1409   
                }
 1423   1410   
                Some(8) => {
 1424   1411   
                    builder.essential = Some(deser.read_boolean(member)?);
 1425   1412   
                }
 1426   1413   
                Some(9) => {
 1427   1414   
                    builder.restart_policy = Some(crate::types::ContainerRestartPolicy::deserialize(deser)?);
 1428   1415   
                }
 1429   1416   
                Some(10) => {
 1430         -
                    builder.entry_point = Some({
 1431         -
                        let container = if let Some(cap) = deser.container_size() {
 1432         -
                            Vec::with_capacity(cap)
 1433         -
                        } else {
 1434         -
                            Vec::new()
 1435         -
                        };
 1436         -
                        deser.read_list(member, container, |mut list, deser| {
 1437         -
                            list.push(deser.read_string(member)?);
 1438         -
                            Ok(list)
 1439         -
                        })?
 1440         -
                    });
        1417  +
                    builder.entry_point = Some(deser.read_string_list(member)?);
 1441   1418   
                }
 1442   1419   
                Some(11) => {
 1443         -
                    builder.command = Some({
 1444         -
                        let container = if let Some(cap) = deser.container_size() {
 1445         -
                            Vec::with_capacity(cap)
 1446         -
                        } else {
 1447         -
                            Vec::new()
 1448         -
                        };
 1449         -
                        deser.read_list(member, container, |mut list, deser| {
 1450         -
                            list.push(deser.read_string(member)?);
 1451         -
                            Ok(list)
 1452         -
                        })?
 1453         -
                    });
        1420  +
                    builder.command = Some(deser.read_string_list(member)?);
 1454   1421   
                }
 1455   1422   
                Some(12) => {
 1456   1423   
                    builder.environment = Some({
 1457         -
                        let container = if let Some(cap) = deser.container_size() {
 1458         -
                            Vec::with_capacity(cap)
 1459         -
                        } else {
 1460         -
                            Vec::new()
 1461         -
                        };
 1462         -
                        deser.read_list(member, container, |mut list, deser| {
 1463         -
                            list.push(crate::types::KeyValuePair::deserialize(deser)?);
 1464         -
                            Ok(list)
 1465         -
                        })?
        1424  +
                        let mut container = Vec::new();
        1425  +
                        deser.read_list(member, &mut |deser| {
        1426  +
                            container.push(crate::types::KeyValuePair::deserialize(deser)?);
        1427  +
                            Ok(())
        1428  +
                        })?;
        1429  +
                        container
 1466   1430   
                    });
 1467   1431   
                }
 1468   1432   
                Some(13) => {
 1469   1433   
                    builder.environment_files = Some({
 1470         -
                        let container = if let Some(cap) = deser.container_size() {
 1471         -
                            Vec::with_capacity(cap)
 1472         -
                        } else {
 1473         -
                            Vec::new()
 1474         -
                        };
 1475         -
                        deser.read_list(member, container, |mut list, deser| {
 1476         -
                            list.push(crate::types::EnvironmentFile::deserialize(deser)?);
 1477         -
                            Ok(list)
 1478         -
                        })?
        1434  +
                        let mut container = Vec::new();
        1435  +
                        deser.read_list(member, &mut |deser| {
        1436  +
                            container.push(crate::types::EnvironmentFile::deserialize(deser)?);
        1437  +
                            Ok(())
        1438  +
                        })?;
        1439  +
                        container
 1479   1440   
                    });
 1480   1441   
                }
 1481   1442   
                Some(14) => {
 1482   1443   
                    builder.mount_points = Some({
 1483         -
                        let container = if let Some(cap) = deser.container_size() {
 1484         -
                            Vec::with_capacity(cap)
 1485         -
                        } else {
 1486         -
                            Vec::new()
 1487         -
                        };
 1488         -
                        deser.read_list(member, container, |mut list, deser| {
 1489         -
                            list.push(crate::types::MountPoint::deserialize(deser)?);
 1490         -
                            Ok(list)
 1491         -
                        })?
        1444  +
                        let mut container = Vec::new();
        1445  +
                        deser.read_list(member, &mut |deser| {
        1446  +
                            container.push(crate::types::MountPoint::deserialize(deser)?);
        1447  +
                            Ok(())
        1448  +
                        })?;
        1449  +
                        container
 1492   1450   
                    });
 1493   1451   
                }
 1494   1452   
                Some(15) => {
 1495   1453   
                    builder.volumes_from = Some({
 1496         -
                        let container = if let Some(cap) = deser.container_size() {
 1497         -
                            Vec::with_capacity(cap)
 1498         -
                        } else {
 1499         -
                            Vec::new()
 1500         -
                        };
 1501         -
                        deser.read_list(member, container, |mut list, deser| {
 1502         -
                            list.push(crate::types::VolumeFrom::deserialize(deser)?);
 1503         -
                            Ok(list)
 1504         -
                        })?
        1454  +
                        let mut container = Vec::new();
        1455  +
                        deser.read_list(member, &mut |deser| {
        1456  +
                            container.push(crate::types::VolumeFrom::deserialize(deser)?);
        1457  +
                            Ok(())
        1458  +
                        })?;
        1459  +
                        container
 1505   1460   
                    });
 1506   1461   
                }
 1507   1462   
                Some(16) => {
 1508   1463   
                    builder.linux_parameters = Some(crate::types::LinuxParameters::deserialize(deser)?);
 1509   1464   
                }
 1510   1465   
                Some(17) => {
 1511   1466   
                    builder.secrets = Some({
 1512         -
                        let container = if let Some(cap) = deser.container_size() {
 1513         -
                            Vec::with_capacity(cap)
 1514         -
                        } else {
 1515         -
                            Vec::new()
 1516         -
                        };
 1517         -
                        deser.read_list(member, container, |mut list, deser| {
 1518         -
                            list.push(crate::types::Secret::deserialize(deser)?);
 1519         -
                            Ok(list)
 1520         -
                        })?
        1467  +
                        let mut container = Vec::new();
        1468  +
                        deser.read_list(member, &mut |deser| {
        1469  +
                            container.push(crate::types::Secret::deserialize(deser)?);
        1470  +
                            Ok(())
        1471  +
                        })?;
        1472  +
                        container
 1521   1473   
                    });
 1522   1474   
                }
 1523   1475   
                Some(18) => {
 1524   1476   
                    builder.depends_on = Some({
 1525         -
                        let container = if let Some(cap) = deser.container_size() {
 1526         -
                            Vec::with_capacity(cap)
 1527         -
                        } else {
 1528         -
                            Vec::new()
 1529         -
                        };
 1530         -
                        deser.read_list(member, container, |mut list, deser| {
 1531         -
                            list.push(crate::types::ContainerDependency::deserialize(deser)?);
 1532         -
                            Ok(list)
 1533         -
                        })?
        1477  +
                        let mut container = Vec::new();
        1478  +
                        deser.read_list(member, &mut |deser| {
        1479  +
                            container.push(crate::types::ContainerDependency::deserialize(deser)?);
        1480  +
                            Ok(())
        1481  +
                        })?;
        1482  +
                        container
 1534   1483   
                    });
 1535   1484   
                }
 1536   1485   
                Some(19) => {
 1537   1486   
                    builder.start_timeout = Some(deser.read_integer(member)?);
 1538   1487   
                }
 1539   1488   
                Some(20) => {
 1540   1489   
                    builder.stop_timeout = Some(deser.read_integer(member)?);
 1541   1490   
                }
 1542   1491   
                Some(21) => {
 1543   1492   
                    builder.version_consistency = Some(crate::types::VersionConsistency::from(deser.read_string(member)?.as_str()));
 1544   1493   
                }
 1545   1494   
                Some(22) => {
 1546   1495   
                    builder.hostname = Some(deser.read_string(member)?);
 1547   1496   
                }
 1548   1497   
                Some(23) => {
 1549   1498   
                    builder.user = Some(deser.read_string(member)?);
 1550   1499   
                }
 1551   1500   
                Some(24) => {
 1552   1501   
                    builder.working_directory = Some(deser.read_string(member)?);
 1553   1502   
                }
 1554   1503   
                Some(25) => {
 1555   1504   
                    builder.disable_networking = Some(deser.read_boolean(member)?);
 1556   1505   
                }
 1557   1506   
                Some(26) => {
 1558   1507   
                    builder.privileged = Some(deser.read_boolean(member)?);
 1559   1508   
                }
 1560   1509   
                Some(27) => {
 1561   1510   
                    builder.readonly_root_filesystem = Some(deser.read_boolean(member)?);
 1562   1511   
                }
 1563   1512   
                Some(28) => {
 1564         -
                    builder.dns_servers = Some({
 1565         -
                        let container = if let Some(cap) = deser.container_size() {
 1566         -
                            Vec::with_capacity(cap)
 1567         -
                        } else {
 1568         -
                            Vec::new()
 1569         -
                        };
 1570         -
                        deser.read_list(member, container, |mut list, deser| {
 1571         -
                            list.push(deser.read_string(member)?);
 1572         -
                            Ok(list)
 1573         -
                        })?
 1574         -
                    });
        1513  +
                    builder.dns_servers = Some(deser.read_string_list(member)?);
 1575   1514   
                }
 1576   1515   
                Some(29) => {
 1577         -
                    builder.dns_search_domains = Some({
 1578         -
                        let container = if let Some(cap) = deser.container_size() {
 1579         -
                            Vec::with_capacity(cap)
 1580         -
                        } else {
 1581         -
                            Vec::new()
 1582         -
                        };
 1583         -
                        deser.read_list(member, container, |mut list, deser| {
 1584         -
                            list.push(deser.read_string(member)?);
 1585         -
                            Ok(list)
 1586         -
                        })?
 1587         -
                    });
        1516  +
                    builder.dns_search_domains = Some(deser.read_string_list(member)?);
 1588   1517   
                }
 1589   1518   
                Some(30) => {
 1590   1519   
                    builder.extra_hosts = Some({
 1591         -
                        let container = if let Some(cap) = deser.container_size() {
 1592         -
                            Vec::with_capacity(cap)
 1593         -
                        } else {
 1594         -
                            Vec::new()
 1595         -
                        };
 1596         -
                        deser.read_list(member, container, |mut list, deser| {
 1597         -
                            list.push(crate::types::HostEntry::deserialize(deser)?);
 1598         -
                            Ok(list)
 1599         -
                        })?
        1520  +
                        let mut container = Vec::new();
        1521  +
                        deser.read_list(member, &mut |deser| {
        1522  +
                            container.push(crate::types::HostEntry::deserialize(deser)?);
        1523  +
                            Ok(())
        1524  +
                        })?;
        1525  +
                        container
 1600   1526   
                    });
 1601   1527   
                }
 1602   1528   
                Some(31) => {
 1603         -
                    builder.docker_security_options = Some({
 1604         -
                        let container = if let Some(cap) = deser.container_size() {
 1605         -
                            Vec::with_capacity(cap)
 1606         -
                        } else {
 1607         -
                            Vec::new()
 1608         -
                        };
 1609         -
                        deser.read_list(member, container, |mut list, deser| {
 1610         -
                            list.push(deser.read_string(member)?);
 1611         -
                            Ok(list)
 1612         -
                        })?
 1613         -
                    });
        1529  +
                    builder.docker_security_options = Some(deser.read_string_list(member)?);
 1614   1530   
                }
 1615   1531   
                Some(32) => {
 1616   1532   
                    builder.interactive = Some(deser.read_boolean(member)?);
 1617   1533   
                }
 1618   1534   
                Some(33) => {
 1619   1535   
                    builder.pseudo_terminal = Some(deser.read_boolean(member)?);
 1620   1536   
                }
 1621   1537   
                Some(34) => {
 1622         -
                    builder.docker_labels = Some({
 1623         -
                        let container = if let Some(cap) = deser.container_size() {
 1624         -
                            std::collections::HashMap::with_capacity(cap)
 1625         -
                        } else {
 1626         -
                            std::collections::HashMap::new()
 1627         -
                        };
 1628         -
                        deser.read_map(member, container, |mut map, key, deser| {
 1629         -
                            map.insert(key, deser.read_string(member)?);
 1630         -
                            Ok(map)
 1631         -
                        })?
 1632         -
                    });
        1538  +
                    builder.docker_labels = Some(deser.read_string_string_map(member)?);
 1633   1539   
                }
 1634   1540   
                Some(35) => {
 1635   1541   
                    builder.ulimits = Some({
 1636         -
                        let container = if let Some(cap) = deser.container_size() {
 1637         -
                            Vec::with_capacity(cap)
 1638         -
                        } else {
 1639         -
                            Vec::new()
 1640         -
                        };
 1641         -
                        deser.read_list(member, container, |mut list, deser| {
 1642         -
                            list.push(crate::types::Ulimit::deserialize(deser)?);
 1643         -
                            Ok(list)
 1644         -
                        })?
        1542  +
                        let mut container = Vec::new();
        1543  +
                        deser.read_list(member, &mut |deser| {
        1544  +
                            container.push(crate::types::Ulimit::deserialize(deser)?);
        1545  +
                            Ok(())
        1546  +
                        })?;
        1547  +
                        container
 1645   1548   
                    });
 1646   1549   
                }
 1647   1550   
                Some(36) => {
 1648   1551   
                    builder.log_configuration = Some(crate::types::LogConfiguration::deserialize(deser)?);
 1649   1552   
                }
 1650   1553   
                Some(37) => {
 1651   1554   
                    builder.health_check = Some(crate::types::HealthCheck::deserialize(deser)?);
 1652   1555   
                }
 1653   1556   
                Some(38) => {
 1654   1557   
                    builder.system_controls = Some({
 1655         -
                        let container = if let Some(cap) = deser.container_size() {
 1656         -
                            Vec::with_capacity(cap)
 1657         -
                        } else {
 1658         -
                            Vec::new()
 1659         -
                        };
 1660         -
                        deser.read_list(member, container, |mut list, deser| {
 1661         -
                            list.push(crate::types::SystemControl::deserialize(deser)?);
 1662         -
                            Ok(list)
 1663         -
                        })?
        1558  +
                        let mut container = Vec::new();
        1559  +
                        deser.read_list(member, &mut |deser| {
        1560  +
                            container.push(crate::types::SystemControl::deserialize(deser)?);
        1561  +
                            Ok(())
        1562  +
                        })?;
        1563  +
                        container
 1664   1564   
                    });
 1665   1565   
                }
 1666   1566   
                Some(39) => {
 1667   1567   
                    builder.resource_requirements = Some({
 1668         -
                        let container = if let Some(cap) = deser.container_size() {
 1669         -
                            Vec::with_capacity(cap)
 1670         -
                        } else {
 1671         -
                            Vec::new()
 1672         -
                        };
 1673         -
                        deser.read_list(member, container, |mut list, deser| {
 1674         -
                            list.push(crate::types::ResourceRequirement::deserialize(deser)?);
 1675         -
                            Ok(list)
 1676         -
                        })?
        1568  +
                        let mut container = Vec::new();
        1569  +
                        deser.read_list(member, &mut |deser| {
        1570  +
                            container.push(crate::types::ResourceRequirement::deserialize(deser)?);
        1571  +
                            Ok(())
        1572  +
                        })?;
        1573  +
                        container
 1677   1574   
                    });
 1678   1575   
                }
 1679   1576   
                Some(40) => {
 1680   1577   
                    builder.firelens_configuration = Some(crate::types::FirelensConfiguration::deserialize(deser)?);
 1681   1578   
                }
 1682   1579   
                Some(41) => {
 1683         -
                    builder.credential_specs = Some({
 1684         -
                        let container = if let Some(cap) = deser.container_size() {
 1685         -
                            Vec::with_capacity(cap)
 1686         -
                        } else {
 1687         -
                            Vec::new()
 1688         -
                        };
 1689         -
                        deser.read_list(member, container, |mut list, deser| {
 1690         -
                            list.push(deser.read_string(member)?);
 1691         -
                            Ok(list)
 1692         -
                        })?
 1693         -
                    });
        1580  +
                    builder.credential_specs = Some(deser.read_string_list(member)?);
 1694   1581   
                }
 1695   1582   
                _ => {}
 1696   1583   
            }
 1697   1584   
            Ok(())
 1698   1585   
        })?;
 1699   1586   
        Ok(builder.build())
 1700   1587   
    }
 1701   1588   
}
        1589  +
impl ContainerDefinition {
        1590  +
    /// Deserializes this structure from a body deserializer and HTTP response.
        1591  +
    pub fn deserialize_with_response(
        1592  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1593  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
        1594  +
        _status: u16,
        1595  +
        _body: &[u8],
        1596  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1597  +
        Self::deserialize(deserializer)
        1598  +
    }
        1599  +
}
 1702   1600   
impl ContainerDefinition {
 1703   1601   
    /// Creates a new builder-style object to manufacture [`ContainerDefinition`](crate::types::ContainerDefinition).
 1704   1602   
    pub fn builder() -> crate::types::builders::ContainerDefinitionBuilder {
 1705   1603   
        crate::types::builders::ContainerDefinitionBuilder::default()
 1706   1604   
    }
 1707   1605   
}
 1708   1606   
 1709   1607   
/// A builder for [`ContainerDefinition`](crate::types::ContainerDefinition).
 1710   1608   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 1711   1609   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container_dependency.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container_image.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container_instance.rs

@@ -145,145 +359,359 @@
  165    165   
}
  166    166   
static CONTAINERINSTANCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  167    167   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerInstance", "com.amazonaws.ecs", "ContainerInstance");
  168    168   
static CONTAINERINSTANCE_MEMBER_CONTAINER_INSTANCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static(
  170    170   
        "com.amazonaws.ecs#ContainerInstance$containerInstanceArn",
  171    171   
        "com.amazonaws.ecs",
  172    172   
        "ContainerInstance",
  173    173   
    ),
  174    174   
    ::aws_smithy_schema::ShapeType::String,
  175         -
    "container_instance_arn",
         175  +
    "containerInstanceArn",
  176    176   
    0,
  177    177   
);
  178    178   
static CONTAINERINSTANCE_MEMBER_EC2_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  179    179   
    ::aws_smithy_schema::ShapeId::from_static(
  180    180   
        "com.amazonaws.ecs#ContainerInstance$ec2InstanceId",
  181    181   
        "com.amazonaws.ecs",
  182    182   
        "ContainerInstance",
  183    183   
    ),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "ec2_instance_id",
         185  +
    "ec2InstanceId",
  186    186   
    1,
  187    187   
);
  188    188   
static CONTAINERINSTANCE_MEMBER_CAPACITY_PROVIDER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  189    189   
    ::aws_smithy_schema::ShapeId::from_static(
  190    190   
        "com.amazonaws.ecs#ContainerInstance$capacityProviderName",
  191    191   
        "com.amazonaws.ecs",
  192    192   
        "ContainerInstance",
  193    193   
    ),
  194    194   
    ::aws_smithy_schema::ShapeType::String,
  195         -
    "capacity_provider_name",
         195  +
    "capacityProviderName",
  196    196   
    2,
  197    197   
);
  198    198   
static CONTAINERINSTANCE_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  199    199   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerInstance$version", "com.amazonaws.ecs", "ContainerInstance"),
  200    200   
    ::aws_smithy_schema::ShapeType::Long,
  201    201   
    "version",
  202    202   
    3,
  203    203   
);
  204    204   
static CONTAINERINSTANCE_MEMBER_VERSION_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static(
  206    206   
        "com.amazonaws.ecs#ContainerInstance$versionInfo",
  207    207   
        "com.amazonaws.ecs",
  208    208   
        "ContainerInstance",
  209    209   
    ),
  210    210   
    ::aws_smithy_schema::ShapeType::Structure,
  211         -
    "version_info",
         211  +
    "versionInfo",
  212    212   
    4,
  213    213   
);
  214    214   
static CONTAINERINSTANCE_MEMBER_REMAINING_RESOURCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static(
  216    216   
        "com.amazonaws.ecs#ContainerInstance$remainingResources",
  217    217   
        "com.amazonaws.ecs",
  218    218   
        "ContainerInstance",
  219    219   
    ),
  220    220   
    ::aws_smithy_schema::ShapeType::List,
  221         -
    "remaining_resources",
         221  +
    "remainingResources",
  222    222   
    5,
  223    223   
);
  224    224   
static CONTAINERINSTANCE_MEMBER_REGISTERED_RESOURCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  225    225   
    ::aws_smithy_schema::ShapeId::from_static(
  226    226   
        "com.amazonaws.ecs#ContainerInstance$registeredResources",
  227    227   
        "com.amazonaws.ecs",
  228    228   
        "ContainerInstance",
  229    229   
    ),
  230    230   
    ::aws_smithy_schema::ShapeType::List,
  231         -
    "registered_resources",
         231  +
    "registeredResources",
  232    232   
    6,
  233    233   
);
  234    234   
static CONTAINERINSTANCE_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  235    235   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerInstance$status", "com.amazonaws.ecs", "ContainerInstance"),
  236    236   
    ::aws_smithy_schema::ShapeType::String,
  237    237   
    "status",
  238    238   
    7,
  239    239   
);
  240    240   
static CONTAINERINSTANCE_MEMBER_STATUS_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  241    241   
    ::aws_smithy_schema::ShapeId::from_static(
  242    242   
        "com.amazonaws.ecs#ContainerInstance$statusReason",
  243    243   
        "com.amazonaws.ecs",
  244    244   
        "ContainerInstance",
  245    245   
    ),
  246    246   
    ::aws_smithy_schema::ShapeType::String,
  247         -
    "status_reason",
         247  +
    "statusReason",
  248    248   
    8,
  249    249   
);
  250    250   
static CONTAINERINSTANCE_MEMBER_AGENT_CONNECTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  251    251   
    ::aws_smithy_schema::ShapeId::from_static(
  252    252   
        "com.amazonaws.ecs#ContainerInstance$agentConnected",
  253    253   
        "com.amazonaws.ecs",
  254    254   
        "ContainerInstance",
  255    255   
    ),
  256    256   
    ::aws_smithy_schema::ShapeType::Boolean,
  257         -
    "agent_connected",
         257  +
    "agentConnected",
  258    258   
    9,
  259    259   
);
  260    260   
static CONTAINERINSTANCE_MEMBER_RUNNING_TASKS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  261    261   
    ::aws_smithy_schema::ShapeId::from_static(
  262    262   
        "com.amazonaws.ecs#ContainerInstance$runningTasksCount",
  263    263   
        "com.amazonaws.ecs",
  264    264   
        "ContainerInstance",
  265    265   
    ),
  266    266   
    ::aws_smithy_schema::ShapeType::Integer,
  267         -
    "running_tasks_count",
         267  +
    "runningTasksCount",
  268    268   
    10,
  269    269   
);
  270    270   
static CONTAINERINSTANCE_MEMBER_PENDING_TASKS_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  271    271   
    ::aws_smithy_schema::ShapeId::from_static(
  272    272   
        "com.amazonaws.ecs#ContainerInstance$pendingTasksCount",
  273    273   
        "com.amazonaws.ecs",
  274    274   
        "ContainerInstance",
  275    275   
    ),
  276    276   
    ::aws_smithy_schema::ShapeType::Integer,
  277         -
    "pending_tasks_count",
         277  +
    "pendingTasksCount",
  278    278   
    11,
  279    279   
);
  280    280   
static CONTAINERINSTANCE_MEMBER_AGENT_UPDATE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  281    281   
    ::aws_smithy_schema::ShapeId::from_static(
  282    282   
        "com.amazonaws.ecs#ContainerInstance$agentUpdateStatus",
  283    283   
        "com.amazonaws.ecs",
  284    284   
        "ContainerInstance",
  285    285   
    ),
  286    286   
    ::aws_smithy_schema::ShapeType::String,
  287         -
    "agent_update_status",
         287  +
    "agentUpdateStatus",
  288    288   
    12,
  289    289   
);
  290    290   
static CONTAINERINSTANCE_MEMBER_ATTRIBUTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  291    291   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerInstance$attributes", "com.amazonaws.ecs", "ContainerInstance"),
  292    292   
    ::aws_smithy_schema::ShapeType::List,
  293    293   
    "attributes",
  294    294   
    13,
  295    295   
);
  296    296   
static CONTAINERINSTANCE_MEMBER_REGISTERED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  297    297   
    ::aws_smithy_schema::ShapeId::from_static(
  298    298   
        "com.amazonaws.ecs#ContainerInstance$registeredAt",
  299    299   
        "com.amazonaws.ecs",
  300    300   
        "ContainerInstance",
  301    301   
    ),
  302    302   
    ::aws_smithy_schema::ShapeType::Timestamp,
  303         -
    "registered_at",
         303  +
    "registeredAt",
  304    304   
    14,
  305    305   
);
  306    306   
static CONTAINERINSTANCE_MEMBER_ATTACHMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  307    307   
    ::aws_smithy_schema::ShapeId::from_static(
  308    308   
        "com.amazonaws.ecs#ContainerInstance$attachments",
  309    309   
        "com.amazonaws.ecs",
  310    310   
        "ContainerInstance",
  311    311   
    ),
  312    312   
    ::aws_smithy_schema::ShapeType::List,
  313    313   
    "attachments",
  314    314   
    15,
  315    315   
);
  316    316   
static CONTAINERINSTANCE_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  317    317   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerInstance$tags", "com.amazonaws.ecs", "ContainerInstance"),
  318    318   
    ::aws_smithy_schema::ShapeType::List,
  319    319   
    "tags",
  320    320   
    16,
  321    321   
);
  322    322   
static CONTAINERINSTANCE_MEMBER_HEALTH_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  323    323   
    ::aws_smithy_schema::ShapeId::from_static(
  324    324   
        "com.amazonaws.ecs#ContainerInstance$healthStatus",
  325    325   
        "com.amazonaws.ecs",
  326    326   
        "ContainerInstance",
  327    327   
    ),
  328    328   
    ::aws_smithy_schema::ShapeType::Structure,
  329         -
    "health_status",
         329  +
    "healthStatus",
  330    330   
    17,
  331    331   
);
  332    332   
static CONTAINERINSTANCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  333    333   
    CONTAINERINSTANCE_SCHEMA_ID,
  334    334   
    ::aws_smithy_schema::ShapeType::Structure,
  335    335   
    &[
  336    336   
        &CONTAINERINSTANCE_MEMBER_CONTAINER_INSTANCE_ARN,
  337    337   
        &CONTAINERINSTANCE_MEMBER_EC2_INSTANCE_ID,
  338    338   
        &CONTAINERINSTANCE_MEMBER_CAPACITY_PROVIDER_NAME,
  339    339   
        &CONTAINERINSTANCE_MEMBER_VERSION,
@@ -439,439 +623,619 @@
  459    459   
            )?;
  460    460   
        }
  461    461   
        if let Some(ref val) = self.health_status {
  462    462   
            ser.write_struct(&CONTAINERINSTANCE_MEMBER_HEALTH_STATUS, val)?;
  463    463   
        }
  464    464   
        Ok(())
  465    465   
    }
  466    466   
}
  467    467   
impl ContainerInstance {
  468    468   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  469         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  470         -
        deserializer: &mut D,
         469  +
    pub fn deserialize(
         470  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  471    471   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  472    472   
        #[allow(unused_variables, unused_mut)]
  473    473   
        let mut builder = Self::builder();
  474    474   
        #[allow(
  475    475   
            unused_variables,
  476    476   
            unreachable_code,
  477    477   
            clippy::single_match,
  478    478   
            clippy::match_single_binding,
  479    479   
            clippy::diverging_sub_expression
  480    480   
        )]
  481         -
        deserializer.read_struct(&CONTAINERINSTANCE_SCHEMA, (), |_, member, deser| {
         481  +
        deserializer.read_struct(&CONTAINERINSTANCE_SCHEMA, &mut |member, deser| {
  482    482   
            match member.member_index() {
  483    483   
                Some(0) => {
  484    484   
                    builder.container_instance_arn = Some(deser.read_string(member)?);
  485    485   
                }
  486    486   
                Some(1) => {
  487    487   
                    builder.ec2_instance_id = Some(deser.read_string(member)?);
  488    488   
                }
  489    489   
                Some(2) => {
  490    490   
                    builder.capacity_provider_name = Some(deser.read_string(member)?);
  491    491   
                }
  492    492   
                Some(3) => {
  493    493   
                    builder.version = Some(deser.read_long(member)?);
  494    494   
                }
  495    495   
                Some(4) => {
  496    496   
                    builder.version_info = Some(crate::types::VersionInfo::deserialize(deser)?);
  497    497   
                }
  498    498   
                Some(5) => {
  499    499   
                    builder.remaining_resources = Some({
  500         -
                        let container = if let Some(cap) = deser.container_size() {
  501         -
                            Vec::with_capacity(cap)
  502         -
                        } else {
  503         -
                            Vec::new()
  504         -
                        };
  505         -
                        deser.read_list(member, container, |mut list, deser| {
  506         -
                            list.push(crate::types::Resource::deserialize(deser)?);
  507         -
                            Ok(list)
  508         -
                        })?
         500  +
                        let mut container = Vec::new();
         501  +
                        deser.read_list(member, &mut |deser| {
         502  +
                            container.push(crate::types::Resource::deserialize(deser)?);
         503  +
                            Ok(())
         504  +
                        })?;
         505  +
                        container
  509    506   
                    });
  510    507   
                }
  511    508   
                Some(6) => {
  512    509   
                    builder.registered_resources = Some({
  513         -
                        let container = if let Some(cap) = deser.container_size() {
  514         -
                            Vec::with_capacity(cap)
  515         -
                        } else {
  516         -
                            Vec::new()
  517         -
                        };
  518         -
                        deser.read_list(member, container, |mut list, deser| {
  519         -
                            list.push(crate::types::Resource::deserialize(deser)?);
  520         -
                            Ok(list)
  521         -
                        })?
         510  +
                        let mut container = Vec::new();
         511  +
                        deser.read_list(member, &mut |deser| {
         512  +
                            container.push(crate::types::Resource::deserialize(deser)?);
         513  +
                            Ok(())
         514  +
                        })?;
         515  +
                        container
  522    516   
                    });
  523    517   
                }
  524    518   
                Some(7) => {
  525    519   
                    builder.status = Some(deser.read_string(member)?);
  526    520   
                }
  527    521   
                Some(8) => {
  528    522   
                    builder.status_reason = Some(deser.read_string(member)?);
  529    523   
                }
  530    524   
                Some(9) => {
  531    525   
                    builder.agent_connected = Some(deser.read_boolean(member)?);
  532    526   
                }
  533    527   
                Some(10) => {
  534    528   
                    builder.running_tasks_count = Some(deser.read_integer(member)?);
  535    529   
                }
  536    530   
                Some(11) => {
  537    531   
                    builder.pending_tasks_count = Some(deser.read_integer(member)?);
  538    532   
                }
  539    533   
                Some(12) => {
  540    534   
                    builder.agent_update_status = Some(crate::types::AgentUpdateStatus::from(deser.read_string(member)?.as_str()));
  541    535   
                }
  542    536   
                Some(13) => {
  543    537   
                    builder.attributes = Some({
  544         -
                        let container = if let Some(cap) = deser.container_size() {
  545         -
                            Vec::with_capacity(cap)
  546         -
                        } else {
  547         -
                            Vec::new()
  548         -
                        };
  549         -
                        deser.read_list(member, container, |mut list, deser| {
  550         -
                            list.push(crate::types::Attribute::deserialize(deser)?);
  551         -
                            Ok(list)
  552         -
                        })?
         538  +
                        let mut container = Vec::new();
         539  +
                        deser.read_list(member, &mut |deser| {
         540  +
                            container.push(crate::types::Attribute::deserialize(deser)?);
         541  +
                            Ok(())
         542  +
                        })?;
         543  +
                        container
  553    544   
                    });
  554    545   
                }
  555    546   
                Some(14) => {
  556    547   
                    builder.registered_at = Some(deser.read_timestamp(member)?);
  557    548   
                }
  558    549   
                Some(15) => {
  559    550   
                    builder.attachments = Some({
  560         -
                        let container = if let Some(cap) = deser.container_size() {
  561         -
                            Vec::with_capacity(cap)
  562         -
                        } else {
  563         -
                            Vec::new()
  564         -
                        };
  565         -
                        deser.read_list(member, container, |mut list, deser| {
  566         -
                            list.push(crate::types::Attachment::deserialize(deser)?);
  567         -
                            Ok(list)
  568         -
                        })?
         551  +
                        let mut container = Vec::new();
         552  +
                        deser.read_list(member, &mut |deser| {
         553  +
                            container.push(crate::types::Attachment::deserialize(deser)?);
         554  +
                            Ok(())
         555  +
                        })?;
         556  +
                        container
  569    557   
                    });
  570    558   
                }
  571    559   
                Some(16) => {
  572    560   
                    builder.tags = Some({
  573         -
                        let container = if let Some(cap) = deser.container_size() {
  574         -
                            Vec::with_capacity(cap)
  575         -
                        } else {
  576         -
                            Vec::new()
  577         -
                        };
  578         -
                        deser.read_list(member, container, |mut list, deser| {
  579         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  580         -
                            Ok(list)
  581         -
                        })?
         561  +
                        let mut container = Vec::new();
         562  +
                        deser.read_list(member, &mut |deser| {
         563  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         564  +
                            Ok(())
         565  +
                        })?;
         566  +
                        container
  582    567   
                    });
  583    568   
                }
  584    569   
                Some(17) => {
  585    570   
                    builder.health_status = Some(crate::types::ContainerInstanceHealthStatus::deserialize(deser)?);
  586    571   
                }
  587    572   
                _ => {}
  588    573   
            }
  589    574   
            Ok(())
  590    575   
        })?;
  591    576   
        Ok(builder.build())
  592    577   
    }
  593    578   
}
         579  +
impl ContainerInstance {
         580  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         581  +
    pub fn deserialize_with_response(
         582  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         583  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         584  +
        _status: u16,
         585  +
        _body: &[u8],
         586  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         587  +
        Self::deserialize(deserializer)
         588  +
    }
         589  +
}
  594    590   
impl ContainerInstance {
  595    591   
    /// Creates a new builder-style object to manufacture [`ContainerInstance`](crate::types::ContainerInstance).
  596    592   
    pub fn builder() -> crate::types::builders::ContainerInstanceBuilder {
  597    593   
        crate::types::builders::ContainerInstanceBuilder::default()
  598    594   
    }
  599    595   
}
  600    596   
  601    597   
/// A builder for [`ContainerInstance`](crate::types::ContainerInstance).
  602    598   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  603    599   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container_instance_health_status.rs

@@ -6,6 +152,160 @@
   26     26   
    "com.amazonaws.ecs",
   27     27   
    "ContainerInstanceHealthStatus",
   28     28   
);
   29     29   
static CONTAINERINSTANCEHEALTHSTATUS_MEMBER_OVERALL_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.ecs#ContainerInstanceHealthStatus$overallStatus",
   32     32   
        "com.amazonaws.ecs",
   33     33   
        "ContainerInstanceHealthStatus",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "overall_status",
          36  +
    "overallStatus",
   37     37   
    0,
   38     38   
);
   39     39   
static CONTAINERINSTANCEHEALTHSTATUS_MEMBER_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ecs#ContainerInstanceHealthStatus$details",
   42     42   
        "com.amazonaws.ecs",
   43     43   
        "ContainerInstanceHealthStatus",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46     46   
    "details",
   47     47   
    1,
   48     48   
);
   49     49   
static CONTAINERINSTANCEHEALTHSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    CONTAINERINSTANCEHEALTHSTATUS_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[
   53     53   
        &CONTAINERINSTANCEHEALTHSTATUS_MEMBER_OVERALL_STATUS,
   54     54   
        &CONTAINERINSTANCEHEALTHSTATUS_MEMBER_DETAILS,
   55     55   
    ],
   56     56   
);
   57     57   
impl ContainerInstanceHealthStatus {
   58     58   
    /// The schema for this shape.
   59     59   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONTAINERINSTANCEHEALTHSTATUS_SCHEMA;
   60     60   
}
   61     61   
impl ::aws_smithy_schema::serde::SerializableStruct for ContainerInstanceHealthStatus {
   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.overall_status {
   68     68   
            ser.write_string(&CONTAINERINSTANCEHEALTHSTATUS_MEMBER_OVERALL_STATUS, val.as_str())?;
   69     69   
        }
   70     70   
        if let Some(ref val) = self.details {
   71     71   
            ser.write_list(
   72     72   
                &CONTAINERINSTANCEHEALTHSTATUS_MEMBER_DETAILS,
   73     73   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   74     74   
                    for item in val {
   75     75   
                        ser.write_struct(crate::types::InstanceHealthCheckResult::SCHEMA, item)?;
   76     76   
                    }
   77     77   
                    Ok(())
   78     78   
                },
   79     79   
            )?;
   80     80   
        }
   81     81   
        Ok(())
   82     82   
    }
   83     83   
}
   84     84   
impl ContainerInstanceHealthStatus {
   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(&CONTAINERINSTANCEHEALTHSTATUS_SCHEMA, (), |_, member, deser| {
          98  +
        deserializer.read_struct(&CONTAINERINSTANCEHEALTHSTATUS_SCHEMA, &mut |member, deser| {
   99     99   
            match member.member_index() {
  100    100   
                Some(0) => {
  101    101   
                    builder.overall_status = Some(crate::types::InstanceHealthCheckState::from(deser.read_string(member)?.as_str()));
  102    102   
                }
  103    103   
                Some(1) => {
  104    104   
                    builder.details = 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::InstanceHealthCheckResult::deserialize(deser)?);
  112         -
                            Ok(list)
  113         -
                        })?
         105  +
                        let mut container = Vec::new();
         106  +
                        deser.read_list(member, &mut |deser| {
         107  +
                            container.push(crate::types::InstanceHealthCheckResult::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 ContainerInstanceHealthStatus {
         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 ContainerInstanceHealthStatus {
  124    132   
    /// Creates a new builder-style object to manufacture [`ContainerInstanceHealthStatus`](crate::types::ContainerInstanceHealthStatus).
  125    133   
    pub fn builder() -> crate::types::builders::ContainerInstanceHealthStatusBuilder {
  126    134   
        crate::types::builders::ContainerInstanceHealthStatusBuilder::default()
  127    135   
    }
  128    136   
}
  129    137   
  130    138   
/// A builder for [`ContainerInstanceHealthStatus`](crate::types::ContainerInstanceHealthStatus).
  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/ecs/src/types/_container_override.rs

@@ -68,68 +160,160 @@
   88     88   
    "environment",
   89     89   
    2,
   90     90   
);
   91     91   
static CONTAINEROVERRIDE_MEMBER_ENVIRONMENT_FILES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ecs#ContainerOverride$environmentFiles",
   94     94   
        "com.amazonaws.ecs",
   95     95   
        "ContainerOverride",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::List,
   98         -
    "environment_files",
          98  +
    "environmentFiles",
   99     99   
    3,
  100    100   
);
  101    101   
static CONTAINEROVERRIDE_MEMBER_CPU: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerOverride$cpu", "com.amazonaws.ecs", "ContainerOverride"),
  103    103   
    ::aws_smithy_schema::ShapeType::Integer,
  104    104   
    "cpu",
  105    105   
    4,
  106    106   
);
  107    107   
static CONTAINEROVERRIDE_MEMBER_MEMORY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerOverride$memory", "com.amazonaws.ecs", "ContainerOverride"),
  109    109   
    ::aws_smithy_schema::ShapeType::Integer,
  110    110   
    "memory",
  111    111   
    5,
  112    112   
);
  113    113   
static CONTAINEROVERRIDE_MEMBER_MEMORY_RESERVATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  114    114   
    ::aws_smithy_schema::ShapeId::from_static(
  115    115   
        "com.amazonaws.ecs#ContainerOverride$memoryReservation",
  116    116   
        "com.amazonaws.ecs",
  117    117   
        "ContainerOverride",
  118    118   
    ),
  119    119   
    ::aws_smithy_schema::ShapeType::Integer,
  120         -
    "memory_reservation",
         120  +
    "memoryReservation",
  121    121   
    6,
  122    122   
);
  123    123   
static CONTAINEROVERRIDE_MEMBER_RESOURCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  124    124   
    ::aws_smithy_schema::ShapeId::from_static(
  125    125   
        "com.amazonaws.ecs#ContainerOverride$resourceRequirements",
  126    126   
        "com.amazonaws.ecs",
  127    127   
        "ContainerOverride",
  128    128   
    ),
  129    129   
    ::aws_smithy_schema::ShapeType::List,
  130         -
    "resource_requirements",
         130  +
    "resourceRequirements",
  131    131   
    7,
  132    132   
);
  133    133   
static CONTAINEROVERRIDE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  134    134   
    CONTAINEROVERRIDE_SCHEMA_ID,
  135    135   
    ::aws_smithy_schema::ShapeType::Structure,
  136    136   
    &[
  137    137   
        &CONTAINEROVERRIDE_MEMBER_NAME,
  138    138   
        &CONTAINEROVERRIDE_MEMBER_COMMAND,
  139    139   
        &CONTAINEROVERRIDE_MEMBER_ENVIRONMENT,
  140    140   
        &CONTAINEROVERRIDE_MEMBER_ENVIRONMENT_FILES,
@@ -188,188 +332,324 @@
  208    208   
                    }
  209    209   
                    Ok(())
  210    210   
                },
  211    211   
            )?;
  212    212   
        }
  213    213   
        Ok(())
  214    214   
    }
  215    215   
}
  216    216   
impl ContainerOverride {
  217    217   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  218         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  219         -
        deserializer: &mut D,
         218  +
    pub fn deserialize(
         219  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  220    220   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  221    221   
        #[allow(unused_variables, unused_mut)]
  222    222   
        let mut builder = Self::builder();
  223    223   
        #[allow(
  224    224   
            unused_variables,
  225    225   
            unreachable_code,
  226    226   
            clippy::single_match,
  227    227   
            clippy::match_single_binding,
  228    228   
            clippy::diverging_sub_expression
  229    229   
        )]
  230         -
        deserializer.read_struct(&CONTAINEROVERRIDE_SCHEMA, (), |_, member, deser| {
         230  +
        deserializer.read_struct(&CONTAINEROVERRIDE_SCHEMA, &mut |member, deser| {
  231    231   
            match member.member_index() {
  232    232   
                Some(0) => {
  233    233   
                    builder.name = Some(deser.read_string(member)?);
  234    234   
                }
  235    235   
                Some(1) => {
  236         -
                    builder.command = Some({
  237         -
                        let container = if let Some(cap) = deser.container_size() {
  238         -
                            Vec::with_capacity(cap)
  239         -
                        } else {
  240         -
                            Vec::new()
  241         -
                        };
  242         -
                        deser.read_list(member, container, |mut list, deser| {
  243         -
                            list.push(deser.read_string(member)?);
  244         -
                            Ok(list)
  245         -
                        })?
  246         -
                    });
         236  +
                    builder.command = Some(deser.read_string_list(member)?);
  247    237   
                }
  248    238   
                Some(2) => {
  249    239   
                    builder.environment = Some({
  250         -
                        let container = if let Some(cap) = deser.container_size() {
  251         -
                            Vec::with_capacity(cap)
  252         -
                        } else {
  253         -
                            Vec::new()
  254         -
                        };
  255         -
                        deser.read_list(member, container, |mut list, deser| {
  256         -
                            list.push(crate::types::KeyValuePair::deserialize(deser)?);
  257         -
                            Ok(list)
  258         -
                        })?
         240  +
                        let mut container = Vec::new();
         241  +
                        deser.read_list(member, &mut |deser| {
         242  +
                            container.push(crate::types::KeyValuePair::deserialize(deser)?);
         243  +
                            Ok(())
         244  +
                        })?;
         245  +
                        container
  259    246   
                    });
  260    247   
                }
  261    248   
                Some(3) => {
  262    249   
                    builder.environment_files = Some({
  263         -
                        let container = if let Some(cap) = deser.container_size() {
  264         -
                            Vec::with_capacity(cap)
  265         -
                        } else {
  266         -
                            Vec::new()
  267         -
                        };
  268         -
                        deser.read_list(member, container, |mut list, deser| {
  269         -
                            list.push(crate::types::EnvironmentFile::deserialize(deser)?);
  270         -
                            Ok(list)
  271         -
                        })?
         250  +
                        let mut container = Vec::new();
         251  +
                        deser.read_list(member, &mut |deser| {
         252  +
                            container.push(crate::types::EnvironmentFile::deserialize(deser)?);
         253  +
                            Ok(())
         254  +
                        })?;
         255  +
                        container
  272    256   
                    });
  273    257   
                }
  274    258   
                Some(4) => {
  275    259   
                    builder.cpu = Some(deser.read_integer(member)?);
  276    260   
                }
  277    261   
                Some(5) => {
  278    262   
                    builder.memory = Some(deser.read_integer(member)?);
  279    263   
                }
  280    264   
                Some(6) => {
  281    265   
                    builder.memory_reservation = Some(deser.read_integer(member)?);
  282    266   
                }
  283    267   
                Some(7) => {
  284    268   
                    builder.resource_requirements = Some({
  285         -
                        let container = if let Some(cap) = deser.container_size() {
  286         -
                            Vec::with_capacity(cap)
  287         -
                        } else {
  288         -
                            Vec::new()
  289         -
                        };
  290         -
                        deser.read_list(member, container, |mut list, deser| {
  291         -
                            list.push(crate::types::ResourceRequirement::deserialize(deser)?);
  292         -
                            Ok(list)
  293         -
                        })?
         269  +
                        let mut container = Vec::new();
         270  +
                        deser.read_list(member, &mut |deser| {
         271  +
                            container.push(crate::types::ResourceRequirement::deserialize(deser)?);
         272  +
                            Ok(())
         273  +
                        })?;
         274  +
                        container
  294    275   
                    });
  295    276   
                }
  296    277   
                _ => {}
  297    278   
            }
  298    279   
            Ok(())
  299    280   
        })?;
  300    281   
        Ok(builder.build())
  301    282   
    }
  302    283   
}
         284  +
impl ContainerOverride {
         285  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         286  +
    pub fn deserialize_with_response(
         287  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         288  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         289  +
        _status: u16,
         290  +
        _body: &[u8],
         291  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         292  +
        Self::deserialize(deserializer)
         293  +
    }
         294  +
}
  303    295   
impl ContainerOverride {
  304    296   
    /// Creates a new builder-style object to manufacture [`ContainerOverride`](crate::types::ContainerOverride).
  305    297   
    pub fn builder() -> crate::types::builders::ContainerOverrideBuilder {
  306    298   
        crate::types::builders::ContainerOverrideBuilder::default()
  307    299   
    }
  308    300   
}
  309    301   
  310    302   
/// A builder for [`ContainerOverride`](crate::types::ContainerOverride).
  311    303   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  312    304   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container_restart_policy.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_container_state_change.rs

@@ -33,33 +133,133 @@
   53     53   
}
   54     54   
static CONTAINERSTATECHANGE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#ContainerStateChange", "com.amazonaws.ecs", "ContainerStateChange");
   56     56   
static CONTAINERSTATECHANGE_MEMBER_CONTAINER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.ecs#ContainerStateChange$containerName",
   59     59   
        "com.amazonaws.ecs",
   60     60   
        "ContainerStateChange",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "container_name",
          63  +
    "containerName",
   64     64   
    0,
   65     65   
);
   66     66   
static CONTAINERSTATECHANGE_MEMBER_IMAGE_DIGEST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.ecs#ContainerStateChange$imageDigest",
   69     69   
        "com.amazonaws.ecs",
   70     70   
        "ContainerStateChange",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "image_digest",
          73  +
    "imageDigest",
   74     74   
    1,
   75     75   
);
   76     76   
static CONTAINERSTATECHANGE_MEMBER_RUNTIME_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "com.amazonaws.ecs#ContainerStateChange$runtimeId",
   79     79   
        "com.amazonaws.ecs",
   80     80   
        "ContainerStateChange",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "runtime_id",
          83  +
    "runtimeId",
   84     84   
    2,
   85     85   
);
   86     86   
static CONTAINERSTATECHANGE_MEMBER_EXIT_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.ecs#ContainerStateChange$exitCode",
   89     89   
        "com.amazonaws.ecs",
   90     90   
        "ContainerStateChange",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::Integer,
   93         -
    "exit_code",
          93  +
    "exitCode",
   94     94   
    3,
   95     95   
);
   96     96   
static CONTAINERSTATECHANGE_MEMBER_NETWORK_BINDINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.ecs#ContainerStateChange$networkBindings",
   99     99   
        "com.amazonaws.ecs",
  100    100   
        "ContainerStateChange",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::List,
  103         -
    "network_bindings",
         103  +
    "networkBindings",
  104    104   
    4,
  105    105   
);
  106    106   
static CONTAINERSTATECHANGE_MEMBER_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.ecs#ContainerStateChange$reason",
  109    109   
        "com.amazonaws.ecs",
  110    110   
        "ContainerStateChange",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::String,
  113    113   
    "reason",
@@ -153,153 +264,272 @@
  173    173   
            ser.write_string(&CONTAINERSTATECHANGE_MEMBER_REASON, val)?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.status {
  176    176   
            ser.write_string(&CONTAINERSTATECHANGE_MEMBER_STATUS, val)?;
  177    177   
        }
  178    178   
        Ok(())
  179    179   
    }
  180    180   
}
  181    181   
impl ContainerStateChange {
  182    182   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  183         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  184         -
        deserializer: &mut D,
         183  +
    pub fn deserialize(
         184  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  185    185   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  186    186   
        #[allow(unused_variables, unused_mut)]
  187    187   
        let mut builder = Self::builder();
  188    188   
        #[allow(
  189    189   
            unused_variables,
  190    190   
            unreachable_code,
  191    191   
            clippy::single_match,
  192    192   
            clippy::match_single_binding,
  193    193   
            clippy::diverging_sub_expression
  194    194   
        )]
  195         -
        deserializer.read_struct(&CONTAINERSTATECHANGE_SCHEMA, (), |_, member, deser| {
         195  +
        deserializer.read_struct(&CONTAINERSTATECHANGE_SCHEMA, &mut |member, deser| {
  196    196   
            match member.member_index() {
  197    197   
                Some(0) => {
  198    198   
                    builder.container_name = Some(deser.read_string(member)?);
  199    199   
                }
  200    200   
                Some(1) => {
  201    201   
                    builder.image_digest = Some(deser.read_string(member)?);
  202    202   
                }
  203    203   
                Some(2) => {
  204    204   
                    builder.runtime_id = Some(deser.read_string(member)?);
  205    205   
                }
  206    206   
                Some(3) => {
  207    207   
                    builder.exit_code = Some(deser.read_integer(member)?);
  208    208   
                }
  209    209   
                Some(4) => {
  210    210   
                    builder.network_bindings = Some({
  211         -
                        let container = if let Some(cap) = deser.container_size() {
  212         -
                            Vec::with_capacity(cap)
  213         -
                        } else {
  214         -
                            Vec::new()
  215         -
                        };
  216         -
                        deser.read_list(member, container, |mut list, deser| {
  217         -
                            list.push(crate::types::NetworkBinding::deserialize(deser)?);
  218         -
                            Ok(list)
  219         -
                        })?
         211  +
                        let mut container = Vec::new();
         212  +
                        deser.read_list(member, &mut |deser| {
         213  +
                            container.push(crate::types::NetworkBinding::deserialize(deser)?);
         214  +
                            Ok(())
         215  +
                        })?;
         216  +
                        container
  220    217   
                    });
  221    218   
                }
  222    219   
                Some(5) => {
  223    220   
                    builder.reason = Some(deser.read_string(member)?);
  224    221   
                }
  225    222   
                Some(6) => {
  226    223   
                    builder.status = Some(deser.read_string(member)?);
  227    224   
                }
  228    225   
                _ => {}
  229    226   
            }
  230    227   
            Ok(())
  231    228   
        })?;
  232    229   
        Ok(builder.build())
  233    230   
    }
  234    231   
}
         232  +
impl ContainerStateChange {
         233  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         234  +
    pub fn deserialize_with_response(
         235  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         236  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         237  +
        _status: u16,
         238  +
        _body: &[u8],
         239  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         240  +
        Self::deserialize(deserializer)
         241  +
    }
         242  +
}
  235    243   
impl ContainerStateChange {
  236    244   
    /// Creates a new builder-style object to manufacture [`ContainerStateChange`](crate::types::ContainerStateChange).
  237    245   
    pub fn builder() -> crate::types::builders::ContainerStateChangeBuilder {
  238    246   
        crate::types::builders::ContainerStateChangeBuilder::default()
  239    247   
    }
  240    248   
}
  241    249   
  242    250   
/// A builder for [`ContainerStateChange`](crate::types::ContainerStateChange).
  243    251   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  244    252   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_create_managed_instances_provider_configuration.rs

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

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_created_at.rs

@@ -33,33 +119,130 @@
   53     53   
            ser.write_timestamp(&CREATEDAT_MEMBER_BEFORE, val)?;
   54     54   
        }
   55     55   
        if let Some(ref val) = self.after {
   56     56   
            ser.write_timestamp(&CREATEDAT_MEMBER_AFTER, val)?;
   57     57   
        }
   58     58   
        Ok(())
   59     59   
    }
   60     60   
}
   61     61   
impl CreatedAt {
   62     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   63         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   64         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   65     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   66     66   
        #[allow(unused_variables, unused_mut)]
   67     67   
        let mut builder = Self::builder();
   68     68   
        #[allow(
   69     69   
            unused_variables,
   70     70   
            unreachable_code,
   71     71   
            clippy::single_match,
   72     72   
            clippy::match_single_binding,
   73     73   
            clippy::diverging_sub_expression
   74     74   
        )]
   75         -
        deserializer.read_struct(&CREATEDAT_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&CREATEDAT_SCHEMA, &mut |member, deser| {
   76     76   
            match member.member_index() {
   77     77   
                Some(0) => {
   78     78   
                    builder.before = Some(deser.read_timestamp(member)?);
   79     79   
                }
   80     80   
                Some(1) => {
   81     81   
                    builder.after = Some(deser.read_timestamp(member)?);
   82     82   
                }
   83     83   
                _ => {}
   84     84   
            }
   85     85   
            Ok(())
   86     86   
        })?;
   87     87   
        Ok(builder.build())
   88     88   
    }
   89     89   
}
          90  +
impl CreatedAt {
          91  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          92  +
    pub fn deserialize_with_response(
          93  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          94  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          95  +
        _status: u16,
          96  +
        _body: &[u8],
          97  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          98  +
        Self::deserialize(deserializer)
          99  +
    }
         100  +
}
   90    101   
impl CreatedAt {
   91    102   
    /// Creates a new builder-style object to manufacture [`CreatedAt`](crate::types::CreatedAt).
   92    103   
    pub fn builder() -> crate::types::builders::CreatedAtBuilder {
   93    104   
        crate::types::builders::CreatedAtBuilder::default()
   94    105   
    }
   95    106   
}
   96    107   
   97    108   
/// A builder for [`CreatedAt`](crate::types::CreatedAt).
   98    109   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   99    110   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_deployment.rs

@@ -187,187 +359,359 @@
  207    207   
);
  208    208   
static DEPLOYMENT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  209    209   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$status", "com.amazonaws.ecs", "Deployment"),
  210    210   
    ::aws_smithy_schema::ShapeType::String,
  211    211   
    "status",
  212    212   
    1,
  213    213   
);
  214    214   
static DEPLOYMENT_MEMBER_TASK_DEFINITION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$taskDefinition", "com.amazonaws.ecs", "Deployment"),
  216    216   
    ::aws_smithy_schema::ShapeType::String,
  217         -
    "task_definition",
         217  +
    "taskDefinition",
  218    218   
    2,
  219    219   
);
  220    220   
static DEPLOYMENT_MEMBER_DESIRED_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  221    221   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$desiredCount", "com.amazonaws.ecs", "Deployment"),
  222    222   
    ::aws_smithy_schema::ShapeType::Integer,
  223         -
    "desired_count",
         223  +
    "desiredCount",
  224    224   
    3,
  225    225   
);
  226    226   
static DEPLOYMENT_MEMBER_PENDING_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  227    227   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$pendingCount", "com.amazonaws.ecs", "Deployment"),
  228    228   
    ::aws_smithy_schema::ShapeType::Integer,
  229         -
    "pending_count",
         229  +
    "pendingCount",
  230    230   
    4,
  231    231   
);
  232    232   
static DEPLOYMENT_MEMBER_RUNNING_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  233    233   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$runningCount", "com.amazonaws.ecs", "Deployment"),
  234    234   
    ::aws_smithy_schema::ShapeType::Integer,
  235         -
    "running_count",
         235  +
    "runningCount",
  236    236   
    5,
  237    237   
);
  238    238   
static DEPLOYMENT_MEMBER_FAILED_TASKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  239    239   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$failedTasks", "com.amazonaws.ecs", "Deployment"),
  240    240   
    ::aws_smithy_schema::ShapeType::Integer,
  241         -
    "failed_tasks",
         241  +
    "failedTasks",
  242    242   
    6,
  243    243   
);
  244    244   
static DEPLOYMENT_MEMBER_CREATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  245    245   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$createdAt", "com.amazonaws.ecs", "Deployment"),
  246    246   
    ::aws_smithy_schema::ShapeType::Timestamp,
  247         -
    "created_at",
         247  +
    "createdAt",
  248    248   
    7,
  249    249   
);
  250    250   
static DEPLOYMENT_MEMBER_UPDATED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  251    251   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$updatedAt", "com.amazonaws.ecs", "Deployment"),
  252    252   
    ::aws_smithy_schema::ShapeType::Timestamp,
  253         -
    "updated_at",
         253  +
    "updatedAt",
  254    254   
    8,
  255    255   
);
  256    256   
static DEPLOYMENT_MEMBER_CAPACITY_PROVIDER_STRATEGY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  257    257   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$capacityProviderStrategy", "com.amazonaws.ecs", "Deployment"),
  258    258   
    ::aws_smithy_schema::ShapeType::List,
  259         -
    "capacity_provider_strategy",
         259  +
    "capacityProviderStrategy",
  260    260   
    9,
  261    261   
);
  262    262   
static DEPLOYMENT_MEMBER_LAUNCH_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  263    263   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$launchType", "com.amazonaws.ecs", "Deployment"),
  264    264   
    ::aws_smithy_schema::ShapeType::String,
  265         -
    "launch_type",
         265  +
    "launchType",
  266    266   
    10,
  267    267   
);
  268    268   
static DEPLOYMENT_MEMBER_PLATFORM_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  269    269   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$platformVersion", "com.amazonaws.ecs", "Deployment"),
  270    270   
    ::aws_smithy_schema::ShapeType::String,
  271         -
    "platform_version",
         271  +
    "platformVersion",
  272    272   
    11,
  273    273   
);
  274    274   
static DEPLOYMENT_MEMBER_PLATFORM_FAMILY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  275    275   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$platformFamily", "com.amazonaws.ecs", "Deployment"),
  276    276   
    ::aws_smithy_schema::ShapeType::String,
  277         -
    "platform_family",
         277  +
    "platformFamily",
  278    278   
    12,
  279    279   
);
  280    280   
static DEPLOYMENT_MEMBER_NETWORK_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  281    281   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$networkConfiguration", "com.amazonaws.ecs", "Deployment"),
  282    282   
    ::aws_smithy_schema::ShapeType::Structure,
  283         -
    "network_configuration",
         283  +
    "networkConfiguration",
  284    284   
    13,
  285    285   
);
  286    286   
static DEPLOYMENT_MEMBER_ROLLOUT_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  287    287   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$rolloutState", "com.amazonaws.ecs", "Deployment"),
  288    288   
    ::aws_smithy_schema::ShapeType::String,
  289         -
    "rollout_state",
         289  +
    "rolloutState",
  290    290   
    14,
  291    291   
);
  292    292   
static DEPLOYMENT_MEMBER_ROLLOUT_STATE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  293    293   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$rolloutStateReason", "com.amazonaws.ecs", "Deployment"),
  294    294   
    ::aws_smithy_schema::ShapeType::String,
  295         -
    "rollout_state_reason",
         295  +
    "rolloutStateReason",
  296    296   
    15,
  297    297   
);
  298    298   
static DEPLOYMENT_MEMBER_SERVICE_CONNECT_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  299    299   
    ::aws_smithy_schema::ShapeId::from_static(
  300    300   
        "com.amazonaws.ecs#Deployment$serviceConnectConfiguration",
  301    301   
        "com.amazonaws.ecs",
  302    302   
        "Deployment",
  303    303   
    ),
  304    304   
    ::aws_smithy_schema::ShapeType::Structure,
  305         -
    "service_connect_configuration",
         305  +
    "serviceConnectConfiguration",
  306    306   
    16,
  307    307   
);
  308    308   
static DEPLOYMENT_MEMBER_SERVICE_CONNECT_RESOURCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  309    309   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$serviceConnectResources", "com.amazonaws.ecs", "Deployment"),
  310    310   
    ::aws_smithy_schema::ShapeType::List,
  311         -
    "service_connect_resources",
         311  +
    "serviceConnectResources",
  312    312   
    17,
  313    313   
);
  314    314   
static DEPLOYMENT_MEMBER_VOLUME_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  315    315   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$volumeConfigurations", "com.amazonaws.ecs", "Deployment"),
  316    316   
    ::aws_smithy_schema::ShapeType::List,
  317         -
    "volume_configurations",
         317  +
    "volumeConfigurations",
  318    318   
    18,
  319    319   
);
  320    320   
static DEPLOYMENT_MEMBER_FARGATE_EPHEMERAL_STORAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  321    321   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$fargateEphemeralStorage", "com.amazonaws.ecs", "Deployment"),
  322    322   
    ::aws_smithy_schema::ShapeType::Structure,
  323         -
    "fargate_ephemeral_storage",
         323  +
    "fargateEphemeralStorage",
  324    324   
    19,
  325    325   
);
  326    326   
static DEPLOYMENT_MEMBER_VPC_LATTICE_CONFIGURATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  327    327   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#Deployment$vpcLatticeConfigurations", "com.amazonaws.ecs", "Deployment"),
  328    328   
    ::aws_smithy_schema::ShapeType::List,
  329         -
    "vpc_lattice_configurations",
         329  +
    "vpcLatticeConfigurations",
  330    330   
    20,
  331    331   
);
  332    332   
static DEPLOYMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  333    333   
    DEPLOYMENT_SCHEMA_ID,
  334    334   
    ::aws_smithy_schema::ShapeType::Structure,
  335    335   
    &[
  336    336   
        &DEPLOYMENT_MEMBER_ID,
  337    337   
        &DEPLOYMENT_MEMBER_STATUS,
  338    338   
        &DEPLOYMENT_MEMBER_TASK_DEFINITION,
  339    339   
        &DEPLOYMENT_MEMBER_DESIRED_COUNT,
@@ -443,443 +626,625 @@
  463    463   
                    }
  464    464   
                    Ok(())
  465    465   
                },
  466    466   
            )?;
  467    467   
        }
  468    468   
        Ok(())
  469    469   
    }
  470    470   
}
  471    471   
impl Deployment {
  472    472   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  473         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  474         -
        deserializer: &mut D,
         473  +
    pub fn deserialize(
         474  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  475    475   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  476    476   
        #[allow(unused_variables, unused_mut)]
  477    477   
        let mut builder = Self::builder();
  478    478   
        #[allow(
  479    479   
            unused_variables,
  480    480   
            unreachable_code,
  481    481   
            clippy::single_match,
  482    482   
            clippy::match_single_binding,
  483    483   
            clippy::diverging_sub_expression
  484    484   
        )]
  485         -
        deserializer.read_struct(&DEPLOYMENT_SCHEMA, (), |_, member, deser| {
         485  +
        deserializer.read_struct(&DEPLOYMENT_SCHEMA, &mut |member, deser| {
  486    486   
            match member.member_index() {
  487    487   
                Some(0) => {
  488    488   
                    builder.id = Some(deser.read_string(member)?);
  489    489   
                }
  490    490   
                Some(1) => {
  491    491   
                    builder.status = Some(deser.read_string(member)?);
  492    492   
                }
  493    493   
                Some(2) => {
  494    494   
                    builder.task_definition = Some(deser.read_string(member)?);
  495    495   
                }
  496    496   
                Some(3) => {
  497    497   
                    builder.desired_count = Some(deser.read_integer(member)?);
  498    498   
                }
  499    499   
                Some(4) => {
  500    500   
                    builder.pending_count = Some(deser.read_integer(member)?);
  501    501   
                }
  502    502   
                Some(5) => {
  503    503   
                    builder.running_count = Some(deser.read_integer(member)?);
  504    504   
                }
  505    505   
                Some(6) => {
  506    506   
                    builder.failed_tasks = Some(deser.read_integer(member)?);
  507    507   
                }
  508    508   
                Some(7) => {
  509    509   
                    builder.created_at = Some(deser.read_timestamp(member)?);
  510    510   
                }
  511    511   
                Some(8) => {
  512    512   
                    builder.updated_at = Some(deser.read_timestamp(member)?);
  513    513   
                }
  514    514   
                Some(9) => {
  515    515   
                    builder.capacity_provider_strategy = Some({
  516         -
                        let container = if let Some(cap) = deser.container_size() {
  517         -
                            Vec::with_capacity(cap)
  518         -
                        } else {
  519         -
                            Vec::new()
  520         -
                        };
  521         -
                        deser.read_list(member, container, |mut list, deser| {
  522         -
                            list.push(crate::types::CapacityProviderStrategyItem::deserialize(deser)?);
  523         -
                            Ok(list)
  524         -
                        })?
         516  +
                        let mut container = Vec::new();
         517  +
                        deser.read_list(member, &mut |deser| {
         518  +
                            container.push(crate::types::CapacityProviderStrategyItem::deserialize(deser)?);
         519  +
                            Ok(())
         520  +
                        })?;
         521  +
                        container
  525    522   
                    });
  526    523   
                }
  527    524   
                Some(10) => {
  528    525   
                    builder.launch_type = Some(crate::types::LaunchType::from(deser.read_string(member)?.as_str()));
  529    526   
                }
  530    527   
                Some(11) => {
  531    528   
                    builder.platform_version = Some(deser.read_string(member)?);
  532    529   
                }
  533    530   
                Some(12) => {
  534    531   
                    builder.platform_family = Some(deser.read_string(member)?);
  535    532   
                }
  536    533   
                Some(13) => {
  537    534   
                    builder.network_configuration = Some(crate::types::NetworkConfiguration::deserialize(deser)?);
  538    535   
                }
  539    536   
                Some(14) => {
  540    537   
                    builder.rollout_state = Some(crate::types::DeploymentRolloutState::from(deser.read_string(member)?.as_str()));
  541    538   
                }
  542    539   
                Some(15) => {
  543    540   
                    builder.rollout_state_reason = Some(deser.read_string(member)?);
  544    541   
                }
  545    542   
                Some(16) => {
  546    543   
                    builder.service_connect_configuration = Some(crate::types::ServiceConnectConfiguration::deserialize(deser)?);
  547    544   
                }
  548    545   
                Some(17) => {
  549    546   
                    builder.service_connect_resources = Some({
  550         -
                        let container = if let Some(cap) = deser.container_size() {
  551         -
                            Vec::with_capacity(cap)
  552         -
                        } else {
  553         -
                            Vec::new()
  554         -
                        };
  555         -
                        deser.read_list(member, container, |mut list, deser| {
  556         -
                            list.push(crate::types::ServiceConnectServiceResource::deserialize(deser)?);
  557         -
                            Ok(list)
  558         -
                        })?
         547  +
                        let mut container = Vec::new();
         548  +
                        deser.read_list(member, &mut |deser| {
         549  +
                            container.push(crate::types::ServiceConnectServiceResource::deserialize(deser)?);
         550  +
                            Ok(())
         551  +
                        })?;
         552  +
                        container
  559    553   
                    });
  560    554   
                }
  561    555   
                Some(18) => {
  562    556   
                    builder.volume_configurations = Some({
  563         -
                        let container = if let Some(cap) = deser.container_size() {
  564         -
                            Vec::with_capacity(cap)
  565         -
                        } else {
  566         -
                            Vec::new()
  567         -
                        };
  568         -
                        deser.read_list(member, container, |mut list, deser| {
  569         -
                            list.push(crate::types::ServiceVolumeConfiguration::deserialize(deser)?);
  570         -
                            Ok(list)
  571         -
                        })?
         557  +
                        let mut container = Vec::new();
         558  +
                        deser.read_list(member, &mut |deser| {
         559  +
                            container.push(crate::types::ServiceVolumeConfiguration::deserialize(deser)?);
         560  +
                            Ok(())
         561  +
                        })?;
         562  +
                        container
  572    563   
                    });
  573    564   
                }
  574    565   
                Some(19) => {
  575    566   
                    builder.fargate_ephemeral_storage = Some(crate::types::DeploymentEphemeralStorage::deserialize(deser)?);
  576    567   
                }
  577    568   
                Some(20) => {
  578    569   
                    builder.vpc_lattice_configurations = Some({
  579         -
                        let container = if let Some(cap) = deser.container_size() {
  580         -
                            Vec::with_capacity(cap)
  581         -
                        } else {
  582         -
                            Vec::new()
  583         -
                        };
  584         -
                        deser.read_list(member, container, |mut list, deser| {
  585         -
                            list.push(crate::types::VpcLatticeConfiguration::deserialize(deser)?);
  586         -
                            Ok(list)
  587         -
                        })?
         570  +
                        let mut container = Vec::new();
         571  +
                        deser.read_list(member, &mut |deser| {
         572  +
                            container.push(crate::types::VpcLatticeConfiguration::deserialize(deser)?);
         573  +
                            Ok(())
         574  +
                        })?;
         575  +
                        container
  588    576   
                    });
  589    577   
                }
  590    578   
                _ => {}
  591    579   
            }
  592    580   
            Ok(())
  593    581   
        })?;
  594    582   
        Ok(builder.build())
  595    583   
    }
  596    584   
}
         585  +
impl Deployment {
         586  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         587  +
    pub fn deserialize_with_response(
         588  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         589  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         590  +
        _status: u16,
         591  +
        _body: &[u8],
         592  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         593  +
        Self::deserialize(deserializer)
         594  +
    }
         595  +
}
  597    596   
impl Deployment {
  598    597   
    /// Creates a new builder-style object to manufacture [`Deployment`](crate::types::Deployment).
  599    598   
    pub fn builder() -> crate::types::builders::DeploymentBuilder {
  600    599   
        crate::types::builders::DeploymentBuilder::default()
  601    600   
    }
  602    601   
}
  603    602   
  604    603   
/// A builder for [`Deployment`](crate::types::Deployment).
  605    604   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  606    605   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ecs/src/types/_deployment_alarms.rs

@@ -7,7 +168,172 @@
   27     27   
    /// <p>Determines whether to use the CloudWatch alarm option in the service deployment process.</p>
   28     28   
    pub fn enable(&self) -> bool {
   29     29   
        self.enable
   30     30   
    }
   31     31   
}
   32     32   
static DEPLOYMENTALARMS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#DeploymentAlarms", "com.amazonaws.ecs", "DeploymentAlarms");
   34     34   
static DEPLOYMENTALARMS_MEMBER_ALARM_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#DeploymentAlarms$alarmNames", "com.amazonaws.ecs", "DeploymentAlarms"),
   36     36   
    ::aws_smithy_schema::ShapeType::List,
   37         -
    "alarm_names",
          37  +
    "alarmNames",
   38     38   
    0,
   39     39   
);
   40     40   
static DEPLOYMENTALARMS_MEMBER_ROLLBACK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#DeploymentAlarms$rollback", "com.amazonaws.ecs", "DeploymentAlarms"),
   42     42   
    ::aws_smithy_schema::ShapeType::Boolean,
   43     43   
    "rollback",
   44     44   
    1,
   45     45   
);
   46     46   
static DEPLOYMENTALARMS_MEMBER_ENABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ecs#DeploymentAlarms$enable", "com.amazonaws.ecs", "DeploymentAlarms"),
   48     48   
    ::aws_smithy_schema::ShapeType::Boolean,
   49     49   
    "enable",
   50     50   
    2,
   51     51   
);
   52     52   
static DEPLOYMENTALARMS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   53     53   
    DEPLOYMENTALARMS_SCHEMA_ID,
   54     54   
    ::aws_smithy_schema::ShapeType::Structure,
   55     55   
    &[
   56     56   
        &DEPLOYMENTALARMS_MEMBER_ALARM_NAMES,
   57     57   
        &DEPLOYMENTALARMS_MEMBER_ROLLBACK,
   58     58   
        &DEPLOYMENTALARMS_MEMBER_ENABLE,
   59     59   
    ],
   60     60   
);
   61     61   
impl DeploymentAlarms {
   62     62   
    /// The schema for this shape.
   63     63   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEPLOYMENTALARMS_SCHEMA;
   64     64   
}
   65     65   
impl ::aws_smithy_schema::serde::SerializableStruct for DeploymentAlarms {
   66     66   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   67     67   
    fn serialize_members(
   68     68   
        &self,
   69     69   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   70     70   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   71     71   
        {
   72     72   
            let val = &self.alarm_names;
   73     73   
   74     74   
            ser.write_list(
   75     75   
                &DEPLOYMENTALARMS_MEMBER_ALARM_NAMES,
   76     76   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   77     77   
                    for item in val {
   78     78   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   79     79   
                    }
   80     80   
                    Ok(())
   81     81   
                },
   82     82   
            )?;
   83     83   
        }
   84     84   
        {
   85     85   
            let val = &self.rollback;
   86     86   
            ser.write_boolean(&DEPLOYMENTALARMS_MEMBER_ROLLBACK, *val)?;
   87     87   
        }
   88     88   
        {
   89     89   
            let val = &self.enable;
   90     90   
            ser.write_boolean(&DEPLOYMENTALARMS_MEMBER_ENABLE, *val)?;
   91     91   
        }
   92     92   
        Ok(())
   93     93   
    }
   94     94   
}
   95     95   
impl DeploymentAlarms {
   96     96   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   97         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   98         -
        deserializer: &mut D,
          97  +
    pub fn deserialize(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   99     99   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  100    100   
        #[allow(unused_variables, unused_mut)]
  101    101   
        let mut builder = Self::builder();
  102    102   
        #[allow(
  103    103   
            unused_variables,
  104    104   
            unreachable_code,
  105    105   
            clippy::single_match,
  106    106   
            clippy::match_single_binding,
  107    107   
            clippy::diverging_sub_expression
  108    108   
        )]
  109         -
        deserializer.read_struct(&DEPLOYMENTALARMS_SCHEMA, (), |_, member, deser| {
         109  +
        deserializer.read_struct(&DEPLOYMENTALARMS_SCHEMA, &mut |member, deser| {
  110    110   
            match member.member_index() {
  111    111   
                Some(0) => {
  112         -
                    builder.alarm_names = Some({
  113         -
                        let container = if let Some(cap) = deser.container_size() {
  114         -
                            Vec::with_capacity(cap)
  115         -
                        } else {
  116         -
                            Vec::new()
  117         -
                        };
  118         -
                        deser.read_list(member, container, |mut list, deser| {
  119         -
                            list.push(deser.read_string(member)?);
  120         -
                            Ok(list)
  121         -
                        })?
  122         -
                    });
         112  +
                    builder.alarm_names = Some(deser.read_string_list(member)?);
  123    113   
                }
  124    114   
                Some(1) => {
  125    115   
                    builder.rollback = Some(deser.read_boolean(member)?);
  126    116   
                }
  127    117   
                Some(2) => {
  128    118   
                    builder.enable = Some(deser.read_boolean(member)?);
  129    119   
                }
  130    120   
                _ => {}
  131    121   
            }
  132    122   
            Ok(())
  133    123   
        })?;
         124  +
        builder.alarm_names = builder.alarm_names.or(Some(Vec::new()));
         125  +
        builder.rollback = builder.rollback.or(Some(false));
         126  +
        builder.enable = builder.enable.or(Some(false));
  134    127   
        builder
  135    128   
            .build()
  136    129   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  137    130   
    }
  138    131   
}
         132  +
impl DeploymentAlarms {
         133  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         134  +
    pub fn deserialize_with_response(
         135  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         136  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         137  +
        _status: u16,
         138  +
        _body: &[u8],
         139  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         140  +
        Self::deserialize(deserializer)
         141  +
    }
         142  +
}
  139    143   
impl DeploymentAlarms {
  140    144   
    /// Creates a new builder-style object to manufacture [`DeploymentAlarms`](crate::types::DeploymentAlarms).
  141    145   
    pub fn builder() -> crate::types::builders::DeploymentAlarmsBuilder {
  142    146   
        crate::types::builders::DeploymentAlarmsBuilder::default()
  143    147   
    }
  144    148   
}
  145    149   
  146    150   
/// A builder for [`DeploymentAlarms`](crate::types::DeploymentAlarms).
  147    151   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  148    152   
#[non_exhaustive]