AWS SDK

AWS SDK

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/purchase_host_reservation.rs

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::purchase_host_reservation::PurchaseHostReservationInput,
  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::purchase_host_reservation::PurchaseHostReservationInput,
  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-www-form-urlencoded");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder =
         203  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  203    204   
            builder
  204    205   
        };
  205    206   
        let body = ::aws_smithy_types::body::SdkBody::from(
  206    207   
            crate::protocol_serde::shape_purchase_host_reservation_input::ser_purchase_host_reservation_input_input_input(&input)?,
  207    208   
        );
  208    209   
        if let Some(content_length) = body.content_length() {
  209    210   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         211  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    212   
        }
  212    213   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    214   
    }
  214    215   
}
  215    216   
#[derive(Debug)]
  216    217   
struct PurchaseHostReservationEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PurchaseHostReservationEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "PurchaseHostReservationEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/purchase_reserved_instances_offering.rs

@@ -175,175 +252,253 @@
  195    195   
                _input: &crate::operation::purchase_reserved_instances_offering::PurchaseReservedInstancesOfferingInput,
  196    196   
                output: &mut ::std::string::String,
  197    197   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198    198   
                use ::std::fmt::Write as _;
  199    199   
                ::std::write!(output, "/").expect("formatting should succeed");
  200    200   
                ::std::result::Result::Ok(())
  201    201   
            }
  202    202   
            #[allow(clippy::unnecessary_wraps)]
  203    203   
            fn update_http_builder(
  204    204   
                input: &crate::operation::purchase_reserved_instances_offering::PurchaseReservedInstancesOfferingInput,
  205         -
                builder: ::http::request::Builder,
  206         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         205  +
                builder: ::http_1x::request::Builder,
         206  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207    207   
                let mut uri = ::std::string::String::new();
  208    208   
                uri_base(input, &mut uri)?;
  209    209   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210    210   
            }
  211         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
         211  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         212  +
            builder =
         213  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  213    214   
            builder
  214    215   
        };
  215    216   
        let body = ::aws_smithy_types::body::SdkBody::from(
  216    217   
            crate::protocol_serde::shape_purchase_reserved_instances_offering_input::ser_purchase_reserved_instances_offering_input_input_input(
  217    218   
                &input,
  218    219   
            )?,
  219    220   
        );
  220    221   
        if let Some(content_length) = body.content_length() {
  221    222   
            let content_length = content_length.to_string();
  222         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         223  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  223    224   
        }
  224    225   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  225    226   
    }
  226    227   
}
  227    228   
#[derive(Debug)]
  228    229   
struct PurchaseReservedInstancesOfferingEndpointParamsInterceptor;
  229    230   
  230    231   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PurchaseReservedInstancesOfferingEndpointParamsInterceptor {
  231    232   
    fn name(&self) -> &'static str {
  232    233   
        "PurchaseReservedInstancesOfferingEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/purchase_scheduled_instances.rs

@@ -173,173 +248,249 @@
  193    193   
                _input: &crate::operation::purchase_scheduled_instances::PurchaseScheduledInstancesInput,
  194    194   
                output: &mut ::std::string::String,
  195    195   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  196    196   
                use ::std::fmt::Write as _;
  197    197   
                ::std::write!(output, "/").expect("formatting should succeed");
  198    198   
                ::std::result::Result::Ok(())
  199    199   
            }
  200    200   
            #[allow(clippy::unnecessary_wraps)]
  201    201   
            fn update_http_builder(
  202    202   
                input: &crate::operation::purchase_scheduled_instances::PurchaseScheduledInstancesInput,
  203         -
                builder: ::http::request::Builder,
  204         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         203  +
                builder: ::http_1x::request::Builder,
         204  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  205    205   
                let mut uri = ::std::string::String::new();
  206    206   
                uri_base(input, &mut uri)?;
  207    207   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  208    208   
            }
  209         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  210         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
         209  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         210  +
            builder =
         211  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  211    212   
            builder
  212    213   
        };
  213    214   
        let body = ::aws_smithy_types::body::SdkBody::from(
  214    215   
            crate::protocol_serde::shape_purchase_scheduled_instances_input::ser_purchase_scheduled_instances_input_input_input(&input)?,
  215    216   
        );
  216    217   
        if let Some(content_length) = body.content_length() {
  217    218   
            let content_length = content_length.to_string();
  218         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         219  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  219    220   
        }
  220    221   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  221    222   
    }
  222    223   
}
  223    224   
#[derive(Debug)]
  224    225   
struct PurchaseScheduledInstancesEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PurchaseScheduledInstancesEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "PurchaseScheduledInstancesEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/reboot_instances.rs

@@ -162,162 +237,238 @@
  182    182   
                _input: &crate::operation::reboot_instances::RebootInstancesInput,
  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::reboot_instances::RebootInstancesInput,
  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-www-form-urlencoded");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder =
         200  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  200    201   
            builder
  201    202   
        };
  202    203   
        let body = ::aws_smithy_types::body::SdkBody::from(
  203    204   
            crate::protocol_serde::shape_reboot_instances_input::ser_reboot_instances_input_input_input(&input)?,
  204    205   
        );
  205    206   
        if let Some(content_length) = body.content_length() {
  206    207   
            let content_length = content_length.to_string();
  207         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         208  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  208    209   
        }
  209    210   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  210    211   
    }
  211    212   
}
  212    213   
#[derive(Debug)]
  213    214   
struct RebootInstancesEndpointParamsInterceptor;
  214    215   
  215    216   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RebootInstancesEndpointParamsInterceptor {
  216    217   
    fn name(&self) -> &'static str {
  217    218   
        "RebootInstancesEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/register_image.rs

@@ -162,162 +237,238 @@
  182    182   
                _input: &crate::operation::register_image::RegisterImageInput,
  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::register_image::RegisterImageInput,
  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-www-form-urlencoded");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder =
         200  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  200    201   
            builder
  201    202   
        };
  202    203   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_register_image_input::ser_register_image_input_input_input(
  203    204   
            &input,
  204    205   
        )?);
  205    206   
        if let Some(content_length) = body.content_length() {
  206    207   
            let content_length = content_length.to_string();
  207         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         208  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  208    209   
        }
  209    210   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  210    211   
    }
  211    212   
}
  212    213   
#[derive(Debug)]
  213    214   
struct RegisterImageEndpointParamsInterceptor;
  214    215   
  215    216   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RegisterImageEndpointParamsInterceptor {
  216    217   
    fn name(&self) -> &'static str {
  217    218   
        "RegisterImageEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/register_instance_event_notification_attributes.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/register_transit_gateway_multicast_group_members.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/register_transit_gateway_multicast_group_sources.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/reject_capacity_reservation_billing_ownership.rs

@@ -176,176 +249,250 @@
  196    196   
                _input: &crate::operation::reject_capacity_reservation_billing_ownership::RejectCapacityReservationBillingOwnershipInput,
  197    197   
                output: &mut ::std::string::String,
  198    198   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  199    199   
                use ::std::fmt::Write as _;
  200    200   
                ::std::write!(output, "/").expect("formatting should succeed");
  201    201   
                ::std::result::Result::Ok(())
  202    202   
            }
  203    203   
            #[allow(clippy::unnecessary_wraps)]
  204    204   
            fn update_http_builder(
  205    205   
                input: &crate::operation::reject_capacity_reservation_billing_ownership::RejectCapacityReservationBillingOwnershipInput,
  206         -
                builder: ::http::request::Builder,
  207         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         206  +
                builder: ::http_1x::request::Builder,
         207  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  208    208   
                let mut uri = ::std::string::String::new();
  209    209   
                uri_base(input, &mut uri)?;
  210    210   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  211    211   
            }
  212         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  213         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
         212  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         213  +
            builder =
         214  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  214    215   
            builder
  215    216   
        };
  216    217   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_reject_capacity_reservation_billing_ownership_input::ser_reject_capacity_reservation_billing_ownership_input_input_input(&input)?);
  217    218   
        if let Some(content_length) = body.content_length() {
  218    219   
            let content_length = content_length.to_string();
  219         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         220  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  220    221   
        }
  221    222   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  222    223   
    }
  223    224   
}
  224    225   
#[derive(Debug)]
  225    226   
struct RejectCapacityReservationBillingOwnershipEndpointParamsInterceptor;
  226    227   
  227    228   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RejectCapacityReservationBillingOwnershipEndpointParamsInterceptor {
  228    229   
    fn name(&self) -> &'static str {
  229    230   
        "RejectCapacityReservationBillingOwnershipEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/reject_transit_gateway_multicast_domain_associations.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/reject_transit_gateway_peering_attachment.rs

@@ -175,175 +248,249 @@
  195    195   
                _input: &crate::operation::reject_transit_gateway_peering_attachment::RejectTransitGatewayPeeringAttachmentInput,
  196    196   
                output: &mut ::std::string::String,
  197    197   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198    198   
                use ::std::fmt::Write as _;
  199    199   
                ::std::write!(output, "/").expect("formatting should succeed");
  200    200   
                ::std::result::Result::Ok(())
  201    201   
            }
  202    202   
            #[allow(clippy::unnecessary_wraps)]
  203    203   
            fn update_http_builder(
  204    204   
                input: &crate::operation::reject_transit_gateway_peering_attachment::RejectTransitGatewayPeeringAttachmentInput,
  205         -
                builder: ::http::request::Builder,
  206         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         205  +
                builder: ::http_1x::request::Builder,
         206  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207    207   
                let mut uri = ::std::string::String::new();
  208    208   
                uri_base(input, &mut uri)?;
  209    209   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210    210   
            }
  211         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
         211  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         212  +
            builder =
         213  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  213    214   
            builder
  214    215   
        };
  215    216   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_reject_transit_gateway_peering_attachment_input::ser_reject_transit_gateway_peering_attachment_input_input_input(&input)?);
  216    217   
        if let Some(content_length) = body.content_length() {
  217    218   
            let content_length = content_length.to_string();
  218         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         219  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  219    220   
        }
  220    221   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  221    222   
    }
  222    223   
}
  223    224   
#[derive(Debug)]
  224    225   
struct RejectTransitGatewayPeeringAttachmentEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RejectTransitGatewayPeeringAttachmentEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "RejectTransitGatewayPeeringAttachmentEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/reject_transit_gateway_vpc_attachment.rs

@@ -175,175 +252,253 @@
  195    195   
                _input: &crate::operation::reject_transit_gateway_vpc_attachment::RejectTransitGatewayVpcAttachmentInput,
  196    196   
                output: &mut ::std::string::String,
  197    197   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198    198   
                use ::std::fmt::Write as _;
  199    199   
                ::std::write!(output, "/").expect("formatting should succeed");
  200    200   
                ::std::result::Result::Ok(())
  201    201   
            }
  202    202   
            #[allow(clippy::unnecessary_wraps)]
  203    203   
            fn update_http_builder(
  204    204   
                input: &crate::operation::reject_transit_gateway_vpc_attachment::RejectTransitGatewayVpcAttachmentInput,
  205         -
                builder: ::http::request::Builder,
  206         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         205  +
                builder: ::http_1x::request::Builder,
         206  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207    207   
                let mut uri = ::std::string::String::new();
  208    208   
                uri_base(input, &mut uri)?;
  209    209   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210    210   
            }
  211         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
         211  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         212  +
            builder =
         213  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  213    214   
            builder
  214    215   
        };
  215    216   
        let body = ::aws_smithy_types::body::SdkBody::from(
  216    217   
            crate::protocol_serde::shape_reject_transit_gateway_vpc_attachment_input::ser_reject_transit_gateway_vpc_attachment_input_input_input(
  217    218   
                &input,
  218    219   
            )?,
  219    220   
        );
  220    221   
        if let Some(content_length) = body.content_length() {
  221    222   
            let content_length = content_length.to_string();
  222         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         223  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  223    224   
        }
  224    225   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  225    226   
    }
  226    227   
}
  227    228   
#[derive(Debug)]
  228    229   
struct RejectTransitGatewayVpcAttachmentEndpointParamsInterceptor;
  229    230   
  230    231   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RejectTransitGatewayVpcAttachmentEndpointParamsInterceptor {
  231    232   
    fn name(&self) -> &'static str {
  232    233   
        "RejectTransitGatewayVpcAttachmentEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/reject_vpc_endpoint_connections.rs

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::reject_vpc_endpoint_connections::RejectVpcEndpointConnectionsInput,
  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::reject_vpc_endpoint_connections::RejectVpcEndpointConnectionsInput,
  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-www-form-urlencoded");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder =
         203  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  203    204   
            builder
  204    205   
        };
  205    206   
        let body = ::aws_smithy_types::body::SdkBody::from(
  206    207   
            crate::protocol_serde::shape_reject_vpc_endpoint_connections_input::ser_reject_vpc_endpoint_connections_input_input_input(&input)?,
  207    208   
        );
  208    209   
        if let Some(content_length) = body.content_length() {
  209    210   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         211  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    212   
        }
  212    213   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    214   
    }
  214    215   
}
  215    216   
#[derive(Debug)]
  216    217   
struct RejectVpcEndpointConnectionsEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RejectVpcEndpointConnectionsEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "RejectVpcEndpointConnectionsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/reject_vpc_peering_connection.rs

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::reject_vpc_peering_connection::RejectVpcPeeringConnectionInput,
  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::reject_vpc_peering_connection::RejectVpcPeeringConnectionInput,
  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-www-form-urlencoded");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder =
         203  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  203    204   
            builder
  204    205   
        };
  205    206   
        let body = ::aws_smithy_types::body::SdkBody::from(
  206    207   
            crate::protocol_serde::shape_reject_vpc_peering_connection_input::ser_reject_vpc_peering_connection_input_input_input(&input)?,
  207    208   
        );
  208    209   
        if let Some(content_length) = body.content_length() {
  209    210   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         211  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    212   
        }
  212    213   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    214   
    }
  214    215   
}
  215    216   
#[derive(Debug)]
  216    217   
struct RejectVpcPeeringConnectionEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RejectVpcPeeringConnectionEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "RejectVpcPeeringConnectionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/release_address.rs

@@ -162,162 +237,238 @@
  182    182   
                _input: &crate::operation::release_address::ReleaseAddressInput,
  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::release_address::ReleaseAddressInput,
  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-www-form-urlencoded");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder =
         200  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  200    201   
            builder
  201    202   
        };
  202    203   
        let body = ::aws_smithy_types::body::SdkBody::from(
  203    204   
            crate::protocol_serde::shape_release_address_input::ser_release_address_input_input_input(&input)?,
  204    205   
        );
  205    206   
        if let Some(content_length) = body.content_length() {
  206    207   
            let content_length = content_length.to_string();
  207         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         208  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  208    209   
        }
  209    210   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  210    211   
    }
  211    212   
}
  212    213   
#[derive(Debug)]
  213    214   
struct ReleaseAddressEndpointParamsInterceptor;
  214    215   
  215    216   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ReleaseAddressEndpointParamsInterceptor {
  216    217   
    fn name(&self) -> &'static str {
  217    218   
        "ReleaseAddressEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/release_hosts.rs

@@ -162,162 +237,238 @@
  182    182   
                _input: &crate::operation::release_hosts::ReleaseHostsInput,
  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::release_hosts::ReleaseHostsInput,
  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-www-form-urlencoded");
         198  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         199  +
            builder =
         200  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  200    201   
            builder
  201    202   
        };
  202    203   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_release_hosts_input::ser_release_hosts_input_input_input(
  203    204   
            &input,
  204    205   
        )?);
  205    206   
        if let Some(content_length) = body.content_length() {
  206    207   
            let content_length = content_length.to_string();
  207         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         208  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  208    209   
        }
  209    210   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  210    211   
    }
  211    212   
}
  212    213   
#[derive(Debug)]
  213    214   
struct ReleaseHostsEndpointParamsInterceptor;
  214    215   
  215    216   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ReleaseHostsEndpointParamsInterceptor {
  216    217   
    fn name(&self) -> &'static str {
  217    218   
        "ReleaseHostsEndpointParamsInterceptor"