AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_capacity_provider.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::update_capacity_provider::UpdateCapacityProviderInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::update_capacity_provider::UpdateCapacityProviderInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "AmazonEC2ContainerServiceV20141113.UpdateCapacityProvider",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(
  211    211   
            crate::protocol_serde::shape_update_capacity_provider::ser_update_capacity_provider_input(&input)?,
  212    212   
        );
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct UpdateCapacityProviderEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateCapacityProviderEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "UpdateCapacityProviderEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_cluster.rs

@@ -162,162 +240,240 @@
  182    182   
                _input: &crate::operation::update_cluster::UpdateClusterInput,
  183    183   
                output: &mut ::std::string::String,
  184    184   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  185    185   
                use ::std::fmt::Write as _;
  186    186   
                ::std::write!(output, "/").expect("formatting should succeed");
  187    187   
                ::std::result::Result::Ok(())
  188    188   
            }
  189    189   
            #[allow(clippy::unnecessary_wraps)]
  190    190   
            fn update_http_builder(
  191    191   
                input: &crate::operation::update_cluster::UpdateClusterInput,
  192         -
                builder: ::http::request::Builder,
  193         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         192  +
                builder: ::http_1x::request::Builder,
         193  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                let mut uri = ::std::string::String::new();
  195    195   
                uri_base(input, &mut uri)?;
  196    196   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  197    197   
            }
  198         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  199         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  200    200   
            builder = _header_serialization_settings.set_default_header(
  201    201   
                builder,
  202         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         202  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  203    203   
                "AmazonEC2ContainerServiceV20141113.UpdateCluster",
  204    204   
            );
  205    205   
            builder
  206    206   
        };
  207    207   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_cluster::ser_update_cluster_input(&input)?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct UpdateClusterEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateClusterEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "UpdateClusterEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_cluster_settings.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::update_cluster_settings::UpdateClusterSettingsInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::update_cluster_settings::UpdateClusterSettingsInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "AmazonEC2ContainerServiceV20141113.UpdateClusterSettings",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_cluster_settings::ser_update_cluster_settings_input(
  211    211   
            &input,
  212    212   
        )?);
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct UpdateClusterSettingsEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateClusterSettingsEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "UpdateClusterSettingsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_container_agent.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::update_container_agent::UpdateContainerAgentInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::update_container_agent::UpdateContainerAgentInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "AmazonEC2ContainerServiceV20141113.UpdateContainerAgent",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_container_agent::ser_update_container_agent_input(
  211    211   
            &input,
  212    212   
        )?);
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct UpdateContainerAgentEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateContainerAgentEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "UpdateContainerAgentEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_container_instances_state.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::update_container_instances_state::UpdateContainerInstancesStateInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::update_container_instances_state::UpdateContainerInstancesStateInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "AmazonEC2ContainerServiceV20141113.UpdateContainerInstancesState",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(
  211    211   
            crate::protocol_serde::shape_update_container_instances_state::ser_update_container_instances_state_input(&input)?,
  212    212   
        );
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct UpdateContainerInstancesStateEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateContainerInstancesStateEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "UpdateContainerInstancesStateEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_service.rs

@@ -162,162 +240,240 @@
  182    182   
                _input: &crate::operation::update_service::UpdateServiceInput,
  183    183   
                output: &mut ::std::string::String,
  184    184   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  185    185   
                use ::std::fmt::Write as _;
  186    186   
                ::std::write!(output, "/").expect("formatting should succeed");
  187    187   
                ::std::result::Result::Ok(())
  188    188   
            }
  189    189   
            #[allow(clippy::unnecessary_wraps)]
  190    190   
            fn update_http_builder(
  191    191   
                input: &crate::operation::update_service::UpdateServiceInput,
  192         -
                builder: ::http::request::Builder,
  193         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         192  +
                builder: ::http_1x::request::Builder,
         193  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                let mut uri = ::std::string::String::new();
  195    195   
                uri_base(input, &mut uri)?;
  196    196   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  197    197   
            }
  198         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  199         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  200    200   
            builder = _header_serialization_settings.set_default_header(
  201    201   
                builder,
  202         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         202  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  203    203   
                "AmazonEC2ContainerServiceV20141113.UpdateService",
  204    204   
            );
  205    205   
            builder
  206    206   
        };
  207    207   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_service::ser_update_service_input(&input)?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct UpdateServiceEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateServiceEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "UpdateServiceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_service_primary_task_set.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::update_service_primary_task_set::UpdateServicePrimaryTaskSetInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "AmazonEC2ContainerServiceV20141113.UpdateServicePrimaryTaskSet",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(
  211    211   
            crate::protocol_serde::shape_update_service_primary_task_set::ser_update_service_primary_task_set_input(&input)?,
  212    212   
        );
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct UpdateServicePrimaryTaskSetEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateServicePrimaryTaskSetEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "UpdateServicePrimaryTaskSetEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_task_protection.rs

@@ -165,165 +245,245 @@
  185    185   
                _input: &crate::operation::update_task_protection::UpdateTaskProtectionInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::update_task_protection::UpdateTaskProtectionInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "AmazonEC2ContainerServiceV20141113.UpdateTaskProtection",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_task_protection::ser_update_task_protection_input(
  211    211   
            &input,
  212    212   
        )?);
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  216    216   
        }
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct UpdateTaskProtectionEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTaskProtectionEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "UpdateTaskProtectionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/operation/update_task_set.rs

@@ -162,162 +240,240 @@
  182    182   
                _input: &crate::operation::update_task_set::UpdateTaskSetInput,
  183    183   
                output: &mut ::std::string::String,
  184    184   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  185    185   
                use ::std::fmt::Write as _;
  186    186   
                ::std::write!(output, "/").expect("formatting should succeed");
  187    187   
                ::std::result::Result::Ok(())
  188    188   
            }
  189    189   
            #[allow(clippy::unnecessary_wraps)]
  190    190   
            fn update_http_builder(
  191    191   
                input: &crate::operation::update_task_set::UpdateTaskSetInput,
  192         -
                builder: ::http::request::Builder,
  193         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         192  +
                builder: ::http_1x::request::Builder,
         193  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                let mut uri = ::std::string::String::new();
  195    195   
                uri_base(input, &mut uri)?;
  196    196   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  197    197   
            }
  198         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  199         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  200    200   
            builder = _header_serialization_settings.set_default_header(
  201    201   
                builder,
  202         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         202  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  203    203   
                "AmazonEC2ContainerServiceV20141113.UpdateTaskSet",
  204    204   
            );
  205    205   
            builder
  206    206   
        };
  207    207   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_task_set::ser_update_task_set_input(&input)?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct UpdateTaskSetEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateTaskSetEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "UpdateTaskSetEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ecs/src/serialization_settings.rs

@@ -1,1 +78,83 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/*
    3      3   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 * SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
#![allow(dead_code)]
    8      8   
    9      9   
use aws_smithy_http::header::set_request_header_if_absent;
   10     10   
use aws_smithy_types::config_bag::{Storable, StoreReplace};
   11         -
use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
          11  +
use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
   12     12   
   13     13   
/// Configuration for how default protocol headers are serialized
   14     14   
#[derive(Clone, Debug, Default)]
   15     15   
pub(crate) struct HeaderSerializationSettings {
   16     16   
    omit_default_content_length: bool,
   17     17   
    omit_default_content_type: bool,
   18     18   
}
   19     19   
   20     20   
impl HeaderSerializationSettings {
   21     21   
    /// Creates new [`HeaderSerializationSettings`]
   22     22   
    pub(crate) fn new() -> Self {
   23     23   
        Default::default()
   24     24   
    }
   25     25   
   26     26   
    /// Omit the default `Content-Length` header during serialization
   27     27   
    pub(crate) fn omit_default_content_length(self) -> Self {
   28     28   
        Self {
   29     29   
            omit_default_content_length: true,
   30     30   
            ..self
   31     31   
        }
   32     32   
    }
   33     33   
   34     34   
    /// Omit the default `Content-Type` header during serialization
   35     35   
    pub(crate) fn omit_default_content_type(self) -> Self {
   36     36   
        Self {
   37     37   
            omit_default_content_type: true,
   38     38   
            ..self
   39     39   
        }
   40     40   
    }
   41     41   
   42     42   
    /// Returns true if the given default header name should be serialized
   43     43   
    fn include_header(&self, header: &HeaderName) -> bool {
   44     44   
        (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
   45     45   
    }
   46     46   
   47     47   
    /// Sets a default header on the given request builder if it should be serialized
   48         -
    pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
          48  +
    pub(crate) fn set_default_header(
          49  +
        &self,
          50  +
        mut request: http_1x::request::Builder,
          51  +
        header_name: HeaderName,
          52  +
        value: &str,
          53  +
    ) -> http_1x::request::Builder {
   49     54   
        if self.include_header(&header_name) {
   50     55   
            request = set_request_header_if_absent(request, header_name, value);
   51     56   
        }
   52     57   
        request
   53     58   
    }
   54     59   
}
   55     60   
   56     61   
impl Storable for HeaderSerializationSettings {
   57     62   
    type Storer = StoreReplace<Self>;
   58     63   
}

tmp-codegen-diff/aws-sdk/sdk/glacier/Cargo.toml

@@ -1,1 +164,165 @@
   14     14   
protocol = "aws.protocols#restJson1"
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.11"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24         -
version = "1.5.18"
          24  +
version = "1.6.0"
   25     25   
   26     26   
[dependencies.aws-sigv4]
   27     27   
path = "../aws-sigv4"
   28         -
version = "1.3.7"
          28  +
version = "1.3.8"
   29     29   
   30     30   
[dependencies.aws-smithy-async]
   31     31   
path = "../aws-smithy-async"
   32         -
version = "1.2.7"
          32  +
version = "1.2.8"
   33     33   
   34     34   
[dependencies.aws-smithy-http]
   35     35   
path = "../aws-smithy-http"
   36         -
version = "0.62.6"
          36  +
version = "0.63.0"
   37     37   
   38     38   
[dependencies.aws-smithy-json]
   39     39   
path = "../aws-smithy-json"
   40         -
version = "0.61.9"
          40  +
version = "0.62.0"
   41     41   
   42     42   
[dependencies.aws-smithy-observability]
   43     43   
path = "../aws-smithy-observability"
   44         -
version = "0.2.0"
          44  +
version = "0.2.1"
   45     45   
   46     46   
[dependencies.aws-smithy-runtime]
   47     47   
path = "../aws-smithy-runtime"
   48     48   
features = ["client"]
   49         -
version = "1.9.8"
          49  +
version = "1.10.0"
   50     50   
   51     51   
[dependencies.aws-smithy-runtime-api]
   52     52   
path = "../aws-smithy-runtime-api"
   53         -
features = ["client", "http-02x"]
   54         -
version = "1.10.0"
          53  +
features = ["client", "http-1x"]
          54  +
version = "1.11.0"
   55     55   
   56     56   
[dependencies.aws-smithy-types]
   57     57   
path = "../aws-smithy-types"
   58         -
version = "1.3.6"
          58  +
features = ["http-body-1-x"]
          59  +
version = "1.4.0"
   59     60   
   60     61   
[dependencies.aws-types]
   61     62   
path = "../aws-types"
   62     63   
version = "1.3.11"
   63     64   
   64     65   
[dependencies.bytes]
   65     66   
version = "1.4.0"
   66     67   
   67     68   
[dependencies.fastrand]
   68     69   
version = "2.0.0"
   69     70   
   70     71   
[dependencies.hex]
   71     72   
version = "0.4.3"
   72     73   
   73     74   
[dependencies.http]
   74     75   
version = "0.2.9"
   75     76   
   76     77   
[dependencies.http-1x]
   77     78   
version = "1"
   78     79   
package = "http"
   79     80   
   80     81   
[dependencies.regex-lite]
   81     82   
version = "0.1.5"
   82     83   
   83     84   
[dependencies.ring]
   84     85   
version = "0.17.5"
   85     86   
   86     87   
[dependencies.tracing]
   87     88   
version = "0.1"
   88     89   
[dev-dependencies.aws-config]
   89     90   
path = "../aws-config"
   90     91   
version = "1.8.12"
   91     92   
   92     93   
[dev-dependencies.aws-credential-types]
   93     94   
path = "../aws-credential-types"
   94     95   
features = ["test-util"]
   95     96   
version = "1.2.11"
   96     97   
   97     98   
[dev-dependencies.aws-runtime]
   98     99   
path = "../aws-runtime"
   99    100   
features = ["test-util"]
  100         -
version = "1.5.18"
         101  +
version = "1.6.0"
  101    102   
  102    103   
[dev-dependencies.aws-smithy-async]
  103    104   
path = "../aws-smithy-async"
  104    105   
features = ["test-util"]
  105         -
version = "1.2.7"
         106  +
version = "1.2.8"
  106    107   
  107    108   
[dev-dependencies.aws-smithy-http-client]
  108    109   
path = "../aws-smithy-http-client"
  109    110   
features = ["test-util", "wire-mock"]
  110         -
version = "1.1.5"
         111  +
version = "1.1.6"
  111    112   
  112    113   
[dev-dependencies.aws-smithy-protocol-test]
  113    114   
path = "../aws-smithy-protocol-test"
  114         -
version = "0.63.7"
         115  +
version = "0.63.8"
  115    116   
  116    117   
[dev-dependencies.aws-smithy-runtime]
  117    118   
path = "../aws-smithy-runtime"
  118    119   
features = ["test-util"]
  119         -
version = "1.9.8"
         120  +
version = "1.10.0"
  120    121   
  121    122   
[dev-dependencies.aws-smithy-runtime-api]
  122    123   
path = "../aws-smithy-runtime-api"
  123    124   
features = ["test-util"]
  124         -
version = "1.10.0"
         125  +
version = "1.11.0"
  125    126   
  126    127   
[dev-dependencies.aws-smithy-types]
  127    128   
path = "../aws-smithy-types"
  128         -
features = ["test-util"]
  129         -
version = "1.3.6"
         129  +
features = ["http-body-1-x", "test-util"]
         130  +
version = "1.4.0"
  130    131   
  131    132   
[dev-dependencies.futures-util]
  132    133   
version = "0.3.25"
  133    134   
features = ["alloc"]
  134    135   
default-features = false
  135    136   
  136    137   
[dev-dependencies.pretty_assertions]
  137    138   
version = "1.3.0"
  138    139   
  139    140   
[dev-dependencies.proptest]
  140    141   
version = "1"
  141    142   
  142    143   
[dev-dependencies.serde_json]
  143    144   
version = "1.0.0"
  144    145   
  145    146   
[dev-dependencies.tokio]
  146    147   
version = "1.23.1"
  147    148   
features = ["macros", "test-util", "rt-multi-thread"]
  148    149   
  149    150   
[dev-dependencies.tracing-subscriber]
  150    151   
version = "0.3.16"
  151    152   
features = ["env-filter", "json"]
  152    153   
  153    154   
[dev-dependencies.tracing-test]
  154    155   
version = "0.2.5"
  155    156   
features = ["no-env-filter"]
  156    157   
  157    158   
[features]
  158    159   
behavior-version-latest = []
  159    160   
rustls = ["aws-smithy-runtime/tls-rustls"]
  160    161   
default-https-client = ["aws-smithy-runtime/default-https-client"]
  161    162   
test-util = ["aws-credential-types/test-util", "aws-smithy-runtime/test-util"]
  162         -
rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
         163  +
rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/http-body-1-x", "aws-smithy-types/rt-tokio"]
  163    164   
gated-tests = []
  164    165   
default = ["rustls", "default-https-client", "rt-tokio"]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/glacier_interceptors.rs

@@ -1,1 +44,44 @@
    4      4   
 * SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
// This code is referenced in generated code, so the compiler doesn't realize it is used.
    8      8   
#![allow(dead_code)]
    9      9   
   10     10   
use std::fmt;
   11     11   
use std::marker::PhantomData;
   12     12   
   13     13   
use bytes::Bytes;
   14         -
use http::header::HeaderValue;
          14  +
use http_1x::header::HeaderValue;
   15     15   
use ring::digest::{Context, Digest, SHA256};
   16     16   
   17     17   
use aws_runtime::auth::SigV4OperationSigningConfig;
   18     18   
use aws_sigv4::http_request::SignableBody;
   19     19   
use aws_smithy_runtime_api::box_error::BoxError;
   20     20   
use aws_smithy_runtime_api::client::interceptors::context::{BeforeSerializationInterceptorContextMut, BeforeTransmitInterceptorContextMut};
   21     21   
use aws_smithy_runtime_api::client::interceptors::Intercept;
   22     22   
use aws_smithy_runtime_api::client::orchestrator::{HttpRequest, LoadedRequestBody};
   23     23   
use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
   24     24   
use aws_smithy_types::byte_stream;

tmp-codegen-diff/aws-sdk/sdk/glacier/src/json_errors.rs

@@ -1,1 +45,45 @@
    5      5   
 */
    6      6   
    7      7   
use aws_smithy_json::deserialize::token::skip_value;
    8      8   
use aws_smithy_json::deserialize::{error::DeserializeError, json_token_iter, Token};
    9      9   
use aws_smithy_runtime_api::http::Headers;
   10     10   
use aws_smithy_types::error::metadata::{Builder as ErrorMetadataBuilder, ErrorMetadata};
   11     11   
use std::borrow::Cow;
   12     12   
   13     13   
// currently only used by AwsJson
   14     14   
#[allow(unused)]
   15         -
pub fn is_error<B>(response: &http::Response<B>) -> bool {
          15  +
pub fn is_error<B>(response: &http_1x::Response<B>) -> bool {
   16     16   
    !response.status().is_success()
   17     17   
}
   18     18   
   19     19   
fn sanitize_error_code(error_code: &str) -> &str {
   20     20   
    // Trim a trailing URL from the error code, which is done by removing the longest suffix
   21     21   
    // beginning with a `:`
   22     22   
    let error_code = match error_code.find(':') {
   23     23   
        Some(idx) => &error_code[..idx],
   24     24   
        None => error_code,
   25     25   
    };
@@ -60,60 +120,120 @@
   80     80   
#[cfg(test)]
   81     81   
mod test {
   82     82   
    use crate::json_errors::{parse_error_body, parse_error_metadata, sanitize_error_code};
   83     83   
    use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
   84     84   
    use aws_smithy_types::{body::SdkBody, error::ErrorMetadata};
   85     85   
    use std::borrow::Cow;
   86     86   
   87     87   
    #[test]
   88     88   
    fn error_metadata() {
   89     89   
        let response = HttpResponse::try_from(
   90         -
            http::Response::builder()
          90  +
            http_1x::Response::builder()
   91     91   
                .body(SdkBody::from(r#"{ "__type": "FooError", "message": "Go to foo" }"#))
   92     92   
                .unwrap(),
   93     93   
        )
   94     94   
        .unwrap();
   95     95   
        assert_eq!(
   96     96   
            parse_error_metadata(response.body().bytes().unwrap(), response.headers())
   97     97   
                .unwrap()
   98     98   
                .build(),
   99     99   
            ErrorMetadata::builder().code("FooError").message("Go to foo").build()
  100    100   
        )
@@ -129,129 +180,180 @@
  149    149   
  150    150   
    #[test]
  151    151   
    fn sanitize_namespace() {
  152    152   
        assert_eq!(sanitize_error_code("aws.protocoltests.restjson#FooError"), "FooError");
  153    153   
    }
  154    154   
  155    155   
    // services like lambda use an alternate `Message` instead of `message`
  156    156   
    #[test]
  157    157   
    fn alternative_error_message_names() {
  158    158   
        let response = HttpResponse::try_from(
  159         -
            http::Response::builder()
         159  +
            http_1x::Response::builder()
  160    160   
                .header("x-amzn-errortype", "ResourceNotFoundException")
  161    161   
                .body(SdkBody::from(
  162    162   
                    r#"{
  163    163   
                    "Type": "User",
  164    164   
                    "Message": "Functions from 'us-west-2' are not reachable from us-east-1"
  165    165   
                }"#,
  166    166   
                ))
  167    167   
                .unwrap(),
  168    168   
        )
  169    169   
        .unwrap();

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/abort_multipart_upload.rs

@@ -208,208 +274,274 @@
  228    228   
                    accountId = account_id,
  229    229   
                    vaultName = vault_name,
  230    230   
                    uploadId = upload_id
  231    231   
                )
  232    232   
                .expect("formatting should succeed");
  233    233   
                ::std::result::Result::Ok(())
  234    234   
            }
  235    235   
            #[allow(clippy::unnecessary_wraps)]
  236    236   
            fn update_http_builder(
  237    237   
                input: &crate::operation::abort_multipart_upload::AbortMultipartUploadInput,
  238         -
                builder: ::http::request::Builder,
  239         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         238  +
                builder: ::http_1x::request::Builder,
         239  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  240    240   
                let mut uri = ::std::string::String::new();
  241    241   
                uri_base(input, &mut uri)?;
  242    242   
                ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
  243    243   
            }
  244         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         244  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  245    245   
            builder
  246    246   
        };
  247    247   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  248    248   
  249    249   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  250    250   
    }
  251    251   
}
  252    252   
#[derive(Debug)]
  253    253   
struct AbortMultipartUploadEndpointParamsInterceptor;
  254    254

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/abort_vault_lock.rs

@@ -193,193 +259,259 @@
  213    213   
                    "/{accountId}/vaults/{vaultName}/lock-policy",
  214    214   
                    accountId = account_id,
  215    215   
                    vaultName = vault_name
  216    216   
                )
  217    217   
                .expect("formatting should succeed");
  218    218   
                ::std::result::Result::Ok(())
  219    219   
            }
  220    220   
            #[allow(clippy::unnecessary_wraps)]
  221    221   
            fn update_http_builder(
  222    222   
                input: &crate::operation::abort_vault_lock::AbortVaultLockInput,
  223         -
                builder: ::http::request::Builder,
  224         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         223  +
                builder: ::http_1x::request::Builder,
         224  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  225    225   
                let mut uri = ::std::string::String::new();
  226    226   
                uri_base(input, &mut uri)?;
  227    227   
                ::std::result::Result::Ok(builder.method("DELETE").uri(uri))
  228    228   
            }
  229         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         229  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  230    230   
            builder
  231    231   
        };
  232    232   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  233    233   
  234    234   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  235    235   
    }
  236    236   
}
  237    237   
#[derive(Debug)]
  238    238   
struct AbortVaultLockEndpointParamsInterceptor;
  239    239

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/add_tags_to_vault.rs

@@ -201,201 +275,275 @@
  221    221   
                _input: &crate::operation::add_tags_to_vault::AddTagsToVaultInput,
  222    222   
                mut output: &mut ::std::string::String,
  223    223   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  224    224   
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  225    225   
                query.push_kv("operation", "add");
  226    226   
                ::std::result::Result::Ok(())
  227    227   
            }
  228    228   
            #[allow(clippy::unnecessary_wraps)]
  229    229   
            fn update_http_builder(
  230    230   
                input: &crate::operation::add_tags_to_vault::AddTagsToVaultInput,
  231         -
                builder: ::http::request::Builder,
  232         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         231  +
                builder: ::http_1x::request::Builder,
         232  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  233    233   
                let mut uri = ::std::string::String::new();
  234    234   
                uri_base(input, &mut uri)?;
  235    235   
                uri_query(input, &mut uri)?;
  236    236   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  237    237   
            }
  238         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  239         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         238  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         239  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  240    240   
            builder
  241    241   
        };
  242    242   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_add_tags_to_vault::ser_add_tags_to_vault_input(&input)?);
  243    243   
        if let Some(content_length) = body.content_length() {
  244    244   
            let content_length = content_length.to_string();
  245         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         245  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  246    246   
        }
  247    247   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  248    248   
    }
  249    249   
}
  250    250   
#[derive(Debug)]
  251    251   
struct AddTagsToVaultEndpointParamsInterceptor;
  252    252   
  253    253   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AddTagsToVaultEndpointParamsInterceptor {
  254    254   
    fn name(&self) -> &'static str {
  255    255   
        "AddTagsToVaultEndpointParamsInterceptor"