AWS SDK

rev. 9f5fb9826a6af51ebfb3736d0a778b00ec7b08b3

Files changed:

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

@@ -106,106 +141,145 @@

-106
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.7.0"
-111
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["test-util"]
 version = "1.2.0"
-116
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false
-121
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
-124
 [dev-dependencies.serde_json]

 version = "1.0.0"
-127
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
-131
 [dev-dependencies.tracing-subscriber]
 version = "0.3.16"
 features = ["env-filter", "json"]
-135
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
-+
 [features]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 test-util = ["aws-credential-types/test-util", "aws-smithy-runtime/test-util"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 default = ["rustls", "rt-tokio"]

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

@@ -239,239 +410,411 @@

↥ Expand context

         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UploadArchiveInput>()
             .ok_or("failed to downcast to UploadArchiveInput")?;
-252
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-265
+    }
-266
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod upload_archive_request_test {
 mod upload_archive_test {
-+
     /// Glacier requires that a version header be set on all requests.
     /// Test ID: GlacierVersionHeader
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn glacier_version_header_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-281
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client
             .upload_archive()
             .set_account_id(::std::option::Option::Some("foo".to_owned()))
             .set_vault_name(::std::option::Option::Some("bar".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Amz-Glacier-Version", "2012-06-01")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/foo/vaults/bar/archives", "path was incorrect");
-300
+    }
     /// Glacier requires checksum headers that are cumbersome to provide.
     /// Test ID: GlacierChecksums
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn glacier_checksums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-311
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client
             .upload_archive()
             .set_account_id(::std::option::Option::Some("foo".to_owned()))
             .set_vault_name(::std::option::Option::Some("bar".to_owned()))
             .set_body(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"hello world",
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("X-Amz-Content-Sha256", "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"),
             ("X-Amz-Glacier-Version", "2012-06-01"),
-328
+            (
                 "X-Amz-Sha256-Tree-Hash",
                 "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
             ),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             body,
             "hello world",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/foo/vaults/bar/archives", "path was incorrect");
-343
+    }
     /// Glacier requires that the account id be set, but you can just use a
     /// hyphen (-) to indicate the current account. This should be default
     /// behavior if the customer provides a null or empty string.
     /// Test ID: GlacierAccountIdEmpty
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn glacier_account_id_empty_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-356
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client
             .upload_archive()
             .set_account_id(::std::option::Option::Some("".to_owned()))
             .set_vault_name(::std::option::Option::Some("bar".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Amz-Glacier-Version", "2012-06-01")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/-/vaults/bar/archives", "path was incorrect");
-375
+    }
     /// Glacier requires that the account id be set, but you can just use a
     /// hyphen (-) to indicate the current account. This should be default
     /// behavior if the customer provides a null or empty string.
     /// Test ID: GlacierAccountIdUnset
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn glacier_account_id_unset_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-388
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client

↧ Expand context

             .upload_archive()
             .set_vault_name(::std::option::Option::Some("bar".to_owned()))
             .set_account_id(::std::option::Option::None)
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("X-Amz-Glacier-Version", "2012-06-01")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/-/vaults/bar/archives", "path was incorrect");
-407
+    }
-408
+}
-409
 /// Error type for the `UploadArchiveError` operation.
 #[non_exhaustive]

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

@@ -254,254 +318,319 @@

↥ Expand context

         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UploadMultipartPartInput>()
             .ok_or("failed to downcast to UploadMultipartPartInput")?;
-267
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-280
+    }
-281
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod upload_multipart_part_request_test {
 mod upload_multipart_part_test {
-+
     /// Glacier requires checksum headers that are cumbersome to provide.
     /// Test ID: GlacierMultipartChecksums
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn glacier_multipart_checksums_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-296
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client

↧ Expand context

             .upload_multipart_part()
             .set_account_id(::std::option::Option::Some("foo".to_owned()))
             .set_vault_name(::std::option::Option::Some("bar".to_owned()))
             .set_upload_id(::std::option::Option::Some("baz".to_owned()))
             .set_body(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
                 b"hello world",
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [
             ("X-Amz-Content-Sha256", "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"),
             ("X-Amz-Glacier-Version", "2012-06-01"),
-314
+            (
                 "X-Amz-Sha256-Tree-Hash",
                 "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
             ),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

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

@@ -61,61 +96,100 @@

↥ Expand context

-61
 [dependencies.once_cell]
 version = "1.16"
-64
 [dependencies.regex-lite]
 version = "0.1.5"
-67
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-config]
 path = "../aws-config"
 version = "1.5.3"
-73
 [dev-dependencies.aws-credential-types]
 path = "../aws-credential-types"
 features = ["test-util"]
 version = "1.2.0"
-78
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"

 features = ["client", "test-util"]
 version = "1.6.0"
-83
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
-86
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
-90
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
-+
 [features]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]
 test-util = ["aws-credential-types/test-util", "aws-smithy-runtime/test-util"]
 default = ["rustls", "rt-tokio"]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_change.rs

@@ -214,214 +278,279 @@

↥ Expand context

         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetChangeInput>()
             .ok_or("failed to downcast to GetChangeInput")?;
-227
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-240
+    }
-241
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod get_change_request_test {
 mod get_change_test {
-+
     /// This test validates that change id is correctly trimmed
     /// Test ID: GetChangeTrimChangeId
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn get_change_trim_change_id_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-256
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client

↧ Expand context

             .get_change()
             .set_id(::std::option::Option::Some("/change/SOMECHANGEID".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/2013-04-01/change/SOMECHANGEID", "path was incorrect");
-269
+    }
-270
+}
-271
 /// Error type for the `GetChangeError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum GetChangeError {
     /// <p>The input is not valid.</p>
     InvalidInput(crate::types::error::InvalidInput),
     /// <p>A change with the specified change ID does not exist.</p>
     NoSuchChange(crate::types::error::NoSuchChange),

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/get_reusable_delegation_set.rs

@@ -220,220 +284,285 @@

↥ Expand context

         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<GetReusableDelegationSetInput>()
             .ok_or("failed to downcast to GetReusableDelegationSetInput")?;
-233
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-246
+    }
-247
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod get_reusable_delegation_set_request_test {
 mod get_reusable_delegation_set_test {
-+
     /// This test validates that delegation set id is correctly trimmed
     /// Test ID: GetReusableDelegationSetTrimDelegationSetId
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn get_reusable_delegation_set_trim_delegation_set_id_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-262
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client

↧ Expand context

             .get_reusable_delegation_set()
             .set_id(::std::option::Option::Some("/delegationset/DELEGATIONSETID".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/2013-04-01/delegationset/DELEGATIONSETID", "path was incorrect");
-275
+    }
-276
+}
-277
 /// Error type for the `GetReusableDelegationSetError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum GetReusableDelegationSetError {
     /// <p>A reusable delegation set with the specified ID does not exist.</p>
     DelegationSetNotReusable(crate::types::error::DelegationSetNotReusable),
     /// <p>The input is not valid.</p>
     InvalidInput(crate::types::error::InvalidInput),

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_resource_record_sets.rs

@@ -249,249 +313,314 @@

↥ Expand context

         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<ListResourceRecordSetsInput>()
             .ok_or("failed to downcast to ListResourceRecordSetsInput")?;
-262
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-275
+    }
-276
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod list_resource_record_sets_request_test {
 mod list_resource_record_sets_test {
-+
     /// This test validates that hosted zone is correctly trimmed
     /// Test ID: ListResourceRecordSetsTrimHostedZone
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn list_resource_record_sets_trim_hosted_zone_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-291
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client

↧ Expand context

             .list_resource_record_sets()
             .set_hosted_zone_id(::std::option::Option::Some("/hostedzone/IDOFMYHOSTEDZONE".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/2013-04-01/hostedzone/IDOFMYHOSTEDZONE/rrset", "path was incorrect");
-304
+    }
-305
+}
-306
 /// Error type for the `ListResourceRecordSetsError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum ListResourceRecordSetsError {
     /// <p>The input is not valid.</p>
     InvalidInput(crate::types::error::InvalidInput),
     /// <p>No hosted zone exists with the ID that you specified.</p>
     NoSuchHostedZone(crate::types::error::NoSuchHostedZone),

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/create_multipart_upload.rs

@@ -265,265 +329,330 @@

↥ Expand context

             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .set_key(Some(
                 _input
                     .key
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("key", "A required field was not set"))?,
             ))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-291
+    }
-292
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod create_multipart_upload_request_test {
 mod create_multipart_upload_test {
-+
     /// This test validates that the URI for CreateMultipartUpload is created correctly
     /// Test ID: CreateMultipartUploadUriConstruction
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn create_multipart_upload_uri_construction_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-307
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client

↧ Expand context

             .create_multipart_upload()
             .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))
             .set_key(::std::option::Option::Some("object.txt".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["uploads"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "POST", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/object.txt", "path was incorrect");
-323
+    }
-324
+}
-325
 /// Error type for the `CreateMultipartUploadError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum CreateMultipartUploadError {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/delete_object_tagging.rs

@@ -248,248 +350,351 @@

↥ Expand context

             .ok_or("failed to downcast to DeleteObjectTaggingInput")?;
-249
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-274
+    }
-275
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod delete_object_tagging_request_test {
     ///     S3 clients should escape special characters in Object Keys
     ///     when the Object Key is used as a URI label binding.
 mod delete_object_tagging_test {
-+
     /// S3 clients should escape special characters in Object Keys
     /// when the Object Key is used as a URI label binding.
     ///
     /// Test ID: S3EscapeObjectKeyInUriLabel
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn s3_escape_object_key_in_uri_label_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .endpoint_url("https://s3.us-west-2.amazonaws.com");
-291
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-294
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client
             .delete_object_tagging()
             .set_bucket(::std::option::Option::Some("mybucket".to_owned()))
             .set_key(::std::option::Option::Some("my key.txt".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["tagging"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "DELETE", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/my%20key.txt", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "mybucket.s3.us-west-2.amazonaws.com");
-314
+    }
     ///     S3 clients should preserve an Object Key representing a path
     ///     when the Object Key is used as a URI label binding, but still
     ///     escape special characters.
     /// S3 clients should preserve an Object Key representing a path
     /// when the Object Key is used as a URI label binding, but still
     /// escape special characters.
     ///
     /// Test ID: S3EscapePathObjectKeyInUriLabel
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn s3_escape_path_object_key_in_uri_label_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .endpoint_url("https://s3.us-west-2.amazonaws.com");
-327
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-330
         let config = config_builder.http_client(http_client).build();

↧ Expand context

         let client = crate::Client::from_conf(config);
         let result = client
             .delete_object_tagging()
             .set_bucket(::std::option::Option::Some("mybucket".to_owned()))
             .set_key(::std::option::Option::Some("foo/bar/my key.txt".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_query_params = &["tagging"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "DELETE", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/foo/bar/my%20key.txt", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "mybucket.s3.us-west-2.amazonaws.com");
-350
+    }
-351
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_bucket_location.rs

@@ -233,233 +297,298 @@

↥ Expand context

-233
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_use_s3_express_control_endpoint(Some(true))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-259
+    }
-260
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod get_bucket_location_request_test {
 mod get_bucket_location_test {
-+
     /// This test case validates https://github.com/awslabs/aws-sdk-rust/issues/116
     /// Test ID: GetBucketLocation
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn get_bucket_location_response() {
         let expected_output = crate::operation::get_bucket_location::GetBucketLocationOutput::builder()
             .set_location_constraint(::std::option::Option::Some(
                 "us-west-2"
                     .parse::<crate::types::BucketLocationConstraint>()
                     .expect("static value validated to member"),
             ))
             .build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(::http::response::Builder::new()
         .status(200)

↧ Expand context

                     .body(::aws_smithy_types::body::SdkBody::from("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<LocationConstraint xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">us-west-2</LocationConstraint>"))
                     .unwrap()
                     ).unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-284
         let op = crate::operation::get_bucket_location::GetBucketLocation::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-290
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));
             de.deserialize_nonstreaming(&http_response)
         });
         let parsed = parsed
             .expect("should be successful response")

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/get_object.rs

@@ -316,316 +443,444 @@

↥ Expand context

             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .set_key(Some(
                 _input
                     .key
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("key", "A required field was not set"))?,
             ))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-342
+    }
-343
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod get_object_request_test {
 mod get_object_test {
-+
     /// https://github.com/awslabs/aws-sdk-rust/issues/818
     /// Test ID: GetObjectIfModifiedSince
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn get_object_if_modified_since_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-358
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client
             .get_object()
             .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))
             .set_key(::std::option::Option::Some("object.txt".to_owned()))
             .set_if_modified_since(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                 1626452453, 0.123_f64,
             )))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let expected_headers = [("if-modified-since", "Fri, 16 Jul 2021 16:20:53 GMT")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/object.txt", "path was incorrect");
-377
+    }
     ///     S3 clients should not remove dot segments from request paths.
     /// S3 clients should not remove dot segments from request paths.
     ///
     /// Test ID: S3PreservesLeadingDotSegmentInUriLabel
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn s3_preserves_leading_dot_segment_in_uri_label_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .endpoint_url("https://s3.us-west-2.amazonaws.com");
-388
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-391
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client
             .get_object()
             .set_bucket(::std::option::Option::Some("mybucket".to_owned()))
             .set_key(::std::option::Option::Some("../key.txt".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/../key.txt", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "mybucket.s3.us-west-2.amazonaws.com");
-409
+    }
     ///     S3 clients should not remove dot segments from request paths.
     /// S3 clients should not remove dot segments from request paths.
     ///
     /// Test ID: S3PreservesEmbeddedDotSegmentInUriLabel
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn s3_preserves_embedded_dot_segment_in_uri_label_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder()
             .with_test_defaults()
             .endpoint_url("https://s3.us-west-2.amazonaws.com");
-420
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-423
         let config = config_builder.http_client(http_client).build();

↧ Expand context

         let client = crate::Client::from_conf(config);
         let result = client
             .get_object()
             .set_bucket(::std::option::Option::Some("mybucket".to_owned()))
             .set_key(::std::option::Option::Some("foo/../key.txt".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let body = http_request.body().bytes().expect("body should be strict");
         // No body
         ::pretty_assertions::assert_eq!(::std::str::from_utf8(body).unwrap(), "");
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/foo/../key.txt", "path was incorrect");
         ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "mybucket.s3.us-west-2.amazonaws.com");
-441
+    }
-442
+}
-443
 /// Error type for the `GetObjectError` operation.

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/head_bucket.rs

@@ -229,229 +293,294 @@

↥ Expand context

             .ok_or("failed to downcast to HeadBucketInput")?;
-230
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-255
+    }
-256
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod head_bucket_request_test {
 mod head_bucket_test {
-+
     /// This test case validates https://github.com/smithy-lang/smithy-rs/issues/456
     /// Test ID: HeadObjectEmptyBody
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn head_object_empty_body_response() {
         let expected_output = crate::types::error::NotFound::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("content-type", "application/xml")
                 .header("date", "Thu, 03 Jun 2021 04:05:52 GMT")
                 .header("server", "AmazonS3")
                 .header(
                     "x-amz-id-2",
                     "UTniwu6QmCIjVeuK2ZfeWBOnu7SqMQOS3Vac6B/K4H2ZCawYUl+nDbhGTImuyhZ5DFiojR3Kcz4=",

↧ Expand context

-275
+                )
                 .header("x-amz-request-id", "GRZ6BZ468DF52F2E")
                 .status(404)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-280
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-284
         let op = crate::operation::head_bucket::HeadBucket::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-290
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/head_object.rs

@@ -266,266 +355,356 @@

↥ Expand context

             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .set_key(Some(
                 _input
                     .key
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("key", "A required field was not set"))?,
             ))
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-292
+    }
-293
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod head_object_request_test {
 mod head_object_test {
-+
     /// https://github.com/awslabs/aws-sdk-rust/issues/331
     /// Test ID: HeadObjectUriEncoding
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn head_object_uri_encoding_request() {
         let (http_client, request_receiver) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
         let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
         let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
         let mut config_builder = config_builder;
         config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
-308
         let config = config_builder.http_client(http_client).build();
         let client = crate::Client::from_conf(config);
         let result = client
             .head_object()
             .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))
             .set_key(::std::option::Option::Some("<> `?🐱".to_owned()))
             .send()
             .await;
         let _ = dbg!(result);
         let http_request = request_receiver.expect_request();
         let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
         ::pretty_assertions::assert_eq!(http_request.method(), "HEAD", "method was incorrect");
         ::pretty_assertions::assert_eq!(uri.path(), "/%3C%3E%20%60%3F%F0%9F%90%B1", "path was incorrect");
-322
+    }
     /// This test case validates https://github.com/smithy-lang/smithy-rs/issues/456
     /// Test ID: HeadObjectEmptyBody
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn head_object_empty_body_response() {
         let expected_output = crate::types::error::NotFound::builder().build();
         let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
             ::http::response::Builder::new()
                 .header("content-type", "application/xml")
                 .header("date", "Thu, 03 Jun 2021 04:05:52 GMT")
                 .header("server", "AmazonS3")
                 .header(
                     "x-amz-id-2",
                     "UTniwu6QmCIjVeuK2ZfeWBOnu7SqMQOS3Vac6B/K4H2ZCawYUl+nDbhGTImuyhZ5DFiojR3Kcz4=",

↧ Expand context

-337
+                )
                 .header("x-amz-request-id", "GRZ6BZ468DF52F2E")
                 .status(404)
                 .body(::aws_smithy_types::body::SdkBody::from(""))
                 .unwrap(),
-342
+        )
         .unwrap();
         use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
         use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
-346
         let op = crate::operation::head_object::HeadObject::new();
         let config = op.config().expect("the operation has config");
         let de = config
             .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
             .expect("the config must have a deserializer");
-352
         let parsed = de.deserialize_streaming(&mut http_response);
         let parsed = parsed.unwrap_or_else(|| {
             let http_response =
                 http_response.map(|body| ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(body.bytes().unwrap())));

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_object_versions.rs

@@ -263,263 +327,328 @@

↥ Expand context

-263
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .set_prefix(_input.prefix.clone())
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-289
+    }
-290
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod list_object_versions_request_test {
 mod list_object_versions_test {
-+
     /// Verify that interleaving list elements (DeleteMarker and Version) from different lists works
     /// Test ID: OutOfOrderVersions
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn out_of_order_versions_response() {
         let expected_output = crate::operation::list_object_versions::ListObjectVersionsOutput::builder()
             .set_name(::std::option::Option::Some("sdk-obj-versions-test".to_owned()))
             .set_prefix(::std::option::Option::Some("".to_owned()))
             .set_key_marker(::std::option::Option::Some("".to_owned()))
             .set_version_id_marker(::std::option::Option::Some("".to_owned()))
             .set_max_keys(::std::option::Option::Some(1000))
             .set_is_truncated(::std::option::Option::Some(false))
             .set_delete_markers(::std::option::Option::Some(vec![
                 crate::types::DeleteMarkerEntry::builder()

↧ Expand context

                     .set_key(::std::option::Option::Some("build.gradle.kts".to_owned()))
                     .set_version_id(::std::option::Option::Some("null".to_owned()))
                     .set_is_latest(::std::option::Option::Some(true))
                     .set_last_modified(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                         1234567890, 0_f64,
                     )))
                     .set_owner(::std::option::Option::Some(
                         crate::types::Owner::builder()
                             .set_id(::std::option::Option::Some(
                                 "c1665459250c459f1849ddce9b291fc3a72bcf5220dc8f6391a0a1045c683b34".to_owned(),
                             ))
                             .set_display_name(::std::option::Option::Some("test-name".to_owned()))
                             .build(),
                     ))
                     .build(),
                 crate::types::DeleteMarkerEntry::builder()
                     .set_key(::std::option::Option::Some("file-2".to_owned()))
                     .set_version_id(::std::option::Option::Some("o98RL6vmlOYiymftbX7wgy_4XWQG4AmY".to_owned()))
                     .set_is_latest(::std::option::Option::Some(true))
                     .set_last_modified(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_objects.rs

@@ -265,265 +329,330 @@

↥ Expand context

-265
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
             .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
             .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
             .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
             .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
             .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
             .set_bucket(Some(
                 _input
                     .bucket
                     .clone()
                     .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
             ))
             .set_prefix(_input.prefix.clone())
             .build()

             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-291
+    }
-292
+}
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod list_objects_request_test {
 mod list_objects_test {
-+
     /// This test validates that parsing respects whitespace
     /// Test ID: KeysWithWhitespace
     #[::tokio::test]
     #[allow(unused_mut)]
     #[::tracing_test::traced_test]
     async fn keys_with_whitespace_response() {
         let expected_output = crate::operation::list_objects::ListObjectsOutput::builder()
             .set_max_keys(::std::option::Option::Some(1000))
             .set_is_truncated(::std::option::Option::Some(false))
             .set_marker(::std::option::Option::Some("".to_owned()))
             .set_name(::std::option::Option::Some("bucketname".to_owned()))
             .set_prefix(::std::option::Option::Some("".to_owned()))
             .set_contents(::std::option::Option::Some(vec![
                 crate::types::Object::builder()
                     .set_key(::std::option::Option::Some("    ".to_owned()))

↧ Expand context

                     .set_last_modified(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                         1626452453, 0_f64,
                     )))
                     .set_e_tag(::std::option::Option::Some("\"etag123\"".to_owned()))
                     .set_size(::std::option::Option::Some(0))
                     .set_owner(::std::option::Option::Some(
                         crate::types::Owner::builder()
                             .set_id(::std::option::Option::Some("owner".to_owned()))
                             .build(),
                     ))
                     .set_storage_class(::std::option::Option::Some(
                         "STANDARD"
                             .parse::<crate::types::ObjectStorageClass>()
                             .expect("static value validated to member"),
                     ))
                     .build(),
                 crate::types::Object::builder()
                     .set_key(::std::option::Option::Some(" a ".to_owned()))
                     .set_last_modified(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(
                         1626451330, 0_f64,

Pages: 1 2