AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405

Files changed:

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

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::modify_spot_fleet_request::ModifySpotFleetRequestInput,
  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::modify_spot_fleet_request::ModifySpotFleetRequestInput,
  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_modify_spot_fleet_request_input::ser_modify_spot_fleet_request_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 ModifySpotFleetRequestEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifySpotFleetRequestEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "ModifySpotFleetRequestEndpointParamsInterceptor"

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

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::modify_subnet_attribute::ModifySubnetAttributeInput,
  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::modify_subnet_attribute::ModifySubnetAttributeInput,
  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_modify_subnet_attribute_input::ser_modify_subnet_attribute_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 ModifySubnetAttributeEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifySubnetAttributeEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "ModifySubnetAttributeEndpointParamsInterceptor"

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

@@ -175,175 +248,249 @@
  195    195   
                _input: &crate::operation::modify_traffic_mirror_filter_network_services::ModifyTrafficMirrorFilterNetworkServicesInput,
  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::modify_traffic_mirror_filter_network_services::ModifyTrafficMirrorFilterNetworkServicesInput,
  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_modify_traffic_mirror_filter_network_services_input::ser_modify_traffic_mirror_filter_network_services_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 ModifyTrafficMirrorFilterNetworkServicesEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyTrafficMirrorFilterNetworkServicesEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "ModifyTrafficMirrorFilterNetworkServicesEndpointParamsInterceptor"

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

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::modify_traffic_mirror_filter_rule::ModifyTrafficMirrorFilterRuleInput,
  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::modify_traffic_mirror_filter_rule::ModifyTrafficMirrorFilterRuleInput,
  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_modify_traffic_mirror_filter_rule_input::ser_modify_traffic_mirror_filter_rule_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 ModifyTrafficMirrorFilterRuleEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyTrafficMirrorFilterRuleEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "ModifyTrafficMirrorFilterRuleEndpointParamsInterceptor"

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

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::modify_traffic_mirror_session::ModifyTrafficMirrorSessionInput,
  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::modify_traffic_mirror_session::ModifyTrafficMirrorSessionInput,
  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_modify_traffic_mirror_session_input::ser_modify_traffic_mirror_session_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 ModifyTrafficMirrorSessionEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyTrafficMirrorSessionEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "ModifyTrafficMirrorSessionEndpointParamsInterceptor"

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

@@ -165,165 +240,241 @@
  185    185   
                _input: &crate::operation::modify_transit_gateway::ModifyTransitGatewayInput,
  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::modify_transit_gateway::ModifyTransitGatewayInput,
  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_modify_transit_gateway_input::ser_modify_transit_gateway_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 ModifyTransitGatewayEndpointParamsInterceptor;
  217    218   
  218    219   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyTransitGatewayEndpointParamsInterceptor {
  219    220   
    fn name(&self) -> &'static str {
  220    221   
        "ModifyTransitGatewayEndpointParamsInterceptor"

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

@@ -175,175 +248,249 @@
  195    195   
                _input: &crate::operation::modify_transit_gateway_prefix_list_reference::ModifyTransitGatewayPrefixListReferenceInput,
  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::modify_transit_gateway_prefix_list_reference::ModifyTransitGatewayPrefixListReferenceInput,
  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_modify_transit_gateway_prefix_list_reference_input::ser_modify_transit_gateway_prefix_list_reference_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 ModifyTransitGatewayPrefixListReferenceEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyTransitGatewayPrefixListReferenceEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "ModifyTransitGatewayPrefixListReferenceEndpointParamsInterceptor"

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

@@ -175,175 +252,253 @@
  195    195   
                _input: &crate::operation::modify_transit_gateway_vpc_attachment::ModifyTransitGatewayVpcAttachmentInput,
  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::modify_transit_gateway_vpc_attachment::ModifyTransitGatewayVpcAttachmentInput,
  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_modify_transit_gateway_vpc_attachment_input::ser_modify_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 ModifyTransitGatewayVpcAttachmentEndpointParamsInterceptor;
  229    230   
  230    231   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyTransitGatewayVpcAttachmentEndpointParamsInterceptor {
  231    232   
    fn name(&self) -> &'static str {
  232    233   
        "ModifyTransitGatewayVpcAttachmentEndpointParamsInterceptor"

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

@@ -173,173 +248,249 @@
  193    193   
                _input: &crate::operation::modify_verified_access_endpoint::ModifyVerifiedAccessEndpointInput,
  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::modify_verified_access_endpoint::ModifyVerifiedAccessEndpointInput,
  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_modify_verified_access_endpoint_input::ser_modify_verified_access_endpoint_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 ModifyVerifiedAccessEndpointEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyVerifiedAccessEndpointEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "ModifyVerifiedAccessEndpointEndpointParamsInterceptor"

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

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

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

@@ -173,173 +248,249 @@
  193    193   
                _input: &crate::operation::modify_verified_access_group::ModifyVerifiedAccessGroupInput,
  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::modify_verified_access_group::ModifyVerifiedAccessGroupInput,
  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_modify_verified_access_group_input::ser_modify_verified_access_group_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 ModifyVerifiedAccessGroupEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyVerifiedAccessGroupEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "ModifyVerifiedAccessGroupEndpointParamsInterceptor"

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

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

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

@@ -173,173 +248,249 @@
  193    193   
                _input: &crate::operation::modify_verified_access_instance::ModifyVerifiedAccessInstanceInput,
  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::modify_verified_access_instance::ModifyVerifiedAccessInstanceInput,
  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_modify_verified_access_instance_input::ser_modify_verified_access_instance_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 ModifyVerifiedAccessInstanceEndpointParamsInterceptor;
  225    226   
  226    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyVerifiedAccessInstanceEndpointParamsInterceptor {
  227    228   
    fn name(&self) -> &'static str {
  228    229   
        "ModifyVerifiedAccessInstanceEndpointParamsInterceptor"

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

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

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

@@ -184,184 +261,262 @@
  204    204   
                _input: &crate::operation::modify_verified_access_trust_provider::ModifyVerifiedAccessTrustProviderInput,
  205    205   
                output: &mut ::std::string::String,
  206    206   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  207    207   
                use ::std::fmt::Write as _;
  208    208   
                ::std::write!(output, "/").expect("formatting should succeed");
  209    209   
                ::std::result::Result::Ok(())
  210    210   
            }
  211    211   
            #[allow(clippy::unnecessary_wraps)]
  212    212   
            fn update_http_builder(
  213    213   
                input: &crate::operation::modify_verified_access_trust_provider::ModifyVerifiedAccessTrustProviderInput,
  214         -
                builder: ::http::request::Builder,
  215         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         214  +
                builder: ::http_1x::request::Builder,
         215  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  216    216   
                let mut uri = ::std::string::String::new();
  217    217   
                uri_base(input, &mut uri)?;
  218    218   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  219    219   
            }
  220         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  221         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
         220  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         221  +
            builder =
         222  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-www-form-urlencoded");
  222    223   
            builder
  223    224   
        };
  224    225   
        let body = ::aws_smithy_types::body::SdkBody::from(
  225    226   
            crate::protocol_serde::shape_modify_verified_access_trust_provider_input::ser_modify_verified_access_trust_provider_input_input_input(
  226    227   
                &input,
  227    228   
            )?,
  228    229   
        );
  229    230   
        if let Some(content_length) = body.content_length() {
  230    231   
            let content_length = content_length.to_string();
  231         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         232  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  232    233   
        }
  233    234   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  234    235   
    }
  235    236   
}
  236    237   
#[derive(Debug)]
  237    238   
struct ModifyVerifiedAccessTrustProviderEndpointParamsInterceptor;
  238    239   
  239    240   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyVerifiedAccessTrustProviderEndpointParamsInterceptor {
  240    241   
    fn name(&self) -> &'static str {
  241    242   
        "ModifyVerifiedAccessTrustProviderEndpointParamsInterceptor"

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

@@ -162,162 +237,238 @@
  182    182   
                _input: &crate::operation::modify_volume::ModifyVolumeInput,
  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::modify_volume::ModifyVolumeInput,
  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_modify_volume_input::ser_modify_volume_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 ModifyVolumeEndpointParamsInterceptor;
  214    215   
  215    216   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ModifyVolumeEndpointParamsInterceptor {
  216    217   
    fn name(&self) -> &'static str {
  217    218   
        "ModifyVolumeEndpointParamsInterceptor"