AWS SDK

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

@@ -179,179 +245,245 @@

             .downcast::<crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.account_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("account_id", "cannot be empty or unset"))?;
                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "account_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 ::std::write!(output, "/{accountId}/policies/data-retrieval", accountId = account_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-205
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_data_retrieval_policy::GetDataRetrievalPolicyInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-214
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-219
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-221
+    }
-222
+}
 #[derive(Debug)]
 struct GetDataRetrievalPolicyEndpointParamsInterceptor;
-225

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetDataRetrievalPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetDataRetrievalPolicyEndpointParamsInterceptor"
-229
+    }
-230
     fn read_before_execution(
         &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::<GetDataRetrievalPolicyInput>()
             .ok_or("failed to downcast to GetDataRetrievalPolicyInput")?;
-245

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

@@ -217,217 +284,284 @@

↥ Expand context

                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-222
+                }
                 let input_3 = &_input.job_id;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("job_id", "cannot be empty or unset"))?;
                 let job_id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if job_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "job_id",
                         "cannot be empty or unset",
                     ));
-233
+                }
                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/jobs/{jobId}/output",

                     accountId = account_id,
                     vaultName = vault_name,
                     jobId = job_id
-240
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-243
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_job_output::GetJobOutputInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_get_job_output::ser_get_job_output_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-253
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-258
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-260
+    }
-261
+}
 #[derive(Debug)]
 struct GetJobOutputEndpointParamsInterceptor;
-264

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetJobOutputEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetJobOutputEndpointParamsInterceptor"
-268
+    }
-269
     fn read_before_execution(
         &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::<GetJobOutputInput>()
             .ok_or("failed to downcast to GetJobOutputInput")?;
-284

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

@@ -196,196 +262,262 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-213
+                }
                 ::std::write!(
                     output,

                     "/{accountId}/vaults/{vaultName}/access-policy",
                     accountId = account_id,
                     vaultName = vault_name
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_vault_access_policy::GetVaultAccessPolicyInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-231
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-236
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-238
+    }
-239
+}
 #[derive(Debug)]
 struct GetVaultAccessPolicyEndpointParamsInterceptor;
-242

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetVaultAccessPolicyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetVaultAccessPolicyEndpointParamsInterceptor"
-246
+    }
-247
     fn read_before_execution(
         &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::<GetVaultAccessPolicyInput>()
             .ok_or("failed to downcast to GetVaultAccessPolicyInput")?;
-262

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

@@ -193,193 +259,259 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-210
+                }
                 ::std::write!(
                     output,

                     "/{accountId}/vaults/{vaultName}/lock-policy",
                     accountId = account_id,
                     vaultName = vault_name
-216
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_vault_lock::GetVaultLockInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-228
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-233
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-235
+    }
-236
+}
 #[derive(Debug)]
 struct GetVaultLockEndpointParamsInterceptor;
-239

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetVaultLockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetVaultLockEndpointParamsInterceptor"
-243
+    }
-244
     fn read_before_execution(
         &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::<GetVaultLockInput>()
             .ok_or("failed to downcast to GetVaultLockInput")?;
-259

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

@@ -196,196 +262,262 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-213
+                }
                 ::std::write!(
                     output,

                     "/{accountId}/vaults/{vaultName}/notification-configuration",
                     accountId = account_id,
                     vaultName = vault_name
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_vault_notifications::GetVaultNotificationsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-231
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-236
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-238
+    }
-239
+}
 #[derive(Debug)]
 struct GetVaultNotificationsEndpointParamsInterceptor;
-242

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetVaultNotificationsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetVaultNotificationsEndpointParamsInterceptor"
-246
+    }
-247
     fn read_before_execution(
         &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::<GetVaultNotificationsInput>()
             .ok_or("failed to downcast to GetVaultNotificationsInput")?;
-262

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

@@ -193,193 +268,268 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-199
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-210
+                }
                 ::std::write!(
                     output,

                     "/{accountId}/vaults/{vaultName}/jobs",
                     accountId = account_id,
                     vaultName = vault_name
-216
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-219
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::initiate_job::InitiateJobInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-228
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_initiate_job_input::ser_job_parameters_http_payload(
             &input.job_parameters,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-239
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-241
+    }
-242
+}
 #[derive(Debug)]
 struct InitiateJobEndpointParamsInterceptor;
-245
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InitiateJobEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InitiateJobEndpointParamsInterceptor"

↧ Expand context

-249
+    }
-250
     fn read_before_execution(
         &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::<InitiateJobInput>()
             .ok_or("failed to downcast to InitiateJobInput")?;
-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_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))

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

@@ -196,196 +263,263 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-213
+                }
                 ::std::write!(
                     output,

                     "/{accountId}/vaults/{vaultName}/multipart-uploads",
                     accountId = account_id,
                     vaultName = vault_name
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::initiate_multipart_upload::InitiateMultipartUploadInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_initiate_multipart_upload::ser_initiate_multipart_upload_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-232
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-237
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-239
+    }
-240
+}
 #[derive(Debug)]
 struct InitiateMultipartUploadEndpointParamsInterceptor;
-243

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InitiateMultipartUploadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InitiateMultipartUploadEndpointParamsInterceptor"
-247
+    }
-248
     fn read_before_execution(
         &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::<InitiateMultipartUploadInput>()
             .ok_or("failed to downcast to InitiateMultipartUploadInput")?;
-263

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

@@ -196,196 +271,271 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-213
+                }
                 ::std::write!(
                     output,

                     "/{accountId}/vaults/{vaultName}/lock-policy",
                     accountId = account_id,
                     vaultName = vault_name
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::initiate_vault_lock::InitiateVaultLockInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-231
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_initiate_vault_lock_input::ser_policy_http_payload(
             &input.policy,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-242
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-244
+    }
-245
+}
 #[derive(Debug)]
 struct InitiateVaultLockEndpointParamsInterceptor;
-248
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InitiateVaultLockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InitiateVaultLockEndpointParamsInterceptor"

↧ Expand context

-252
+    }
-253
     fn read_before_execution(
         &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::<InitiateVaultLockInput>()
             .ok_or("failed to downcast to InitiateVaultLockInput")?;
-268
         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))

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

@@ -214,214 +281,281 @@

↥ Expand context

             fn uri_query(
                 _input: &crate::operation::list_jobs::ListJobsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_3) = &_input.limit {
-220
+                    {
                         query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-222
+                    }
-223
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.marker {
-225
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_4));
-227
+                    }
-228
+                }
                 if let ::std::option::Option::Some(inner_5) = &_input.statuscode {
-230
+                    {
                         query.push_kv("statuscode", &::aws_smithy_http::query::fmt_string(inner_5));
-232
+                    }
-233
+                }

                 if let ::std::option::Option::Some(inner_6) = &_input.completed {
-235
+                    {
                         query.push_kv("completed", &::aws_smithy_http::query::fmt_string(inner_6));
-237
+                    }
-238
+                }
                 ::std::result::Result::Ok(())
-240
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_jobs::ListJobsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-250
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-255
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-257
+    }
-258
+}
 #[derive(Debug)]
 struct ListJobsEndpointParamsInterceptor;
-261

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListJobsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListJobsEndpointParamsInterceptor"
-265
+    }
-266
     fn read_before_execution(
         &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::<ListJobsInput>()
             .ok_or("failed to downcast to ListJobsInput")?;
-281

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

@@ -213,213 +280,280 @@

↥ Expand context

-213
+                }
                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/multipart-uploads",
                     accountId = account_id,
                     vaultName = vault_name
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             fn uri_query(
                 _input: &crate::operation::list_multipart_uploads::ListMultipartUploadsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_3) = &_input.limit {
-229
+                    {
                         query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-231
+                    }
-232
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.marker {
-234
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_4));
-236
+                    }
-237
+                }
                 ::std::result::Result::Ok(())
-239
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_multipart_uploads::ListMultipartUploadsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-249
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-254
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-256
+    }
-257
+}
 #[derive(Debug)]
 struct ListMultipartUploadsEndpointParamsInterceptor;
-260

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListMultipartUploadsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListMultipartUploadsEndpointParamsInterceptor"
-264
+    }
-265
     fn read_before_execution(
         &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::<ListMultipartUploadsInput>()
             .ok_or("failed to downcast to ListMultipartUploadsInput")?;
-280

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

@@ -220,220 +287,287 @@

↥ Expand context

                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}",
                     accountId = account_id,
                     vaultName = vault_name,
                     uploadId = upload_id
-226
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-229
+            }
             fn uri_query(
                 _input: &crate::operation::list_parts::ListPartsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_4) = &_input.marker {
-236
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_4));
-238
+                    }
-239
+                }

                 if let ::std::option::Option::Some(inner_5) = &_input.limit {
-241
+                    {
                         query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
-243
+                    }
-244
+                }
                 ::std::result::Result::Ok(())
-246
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_parts::ListPartsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-256
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-261
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-263
+    }
-264
+}
 #[derive(Debug)]
 struct ListPartsEndpointParamsInterceptor;
-267

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListPartsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListPartsEndpointParamsInterceptor"
-271
+    }
-272
     fn read_before_execution(
         &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::<ListPartsInput>()
             .ok_or("failed to downcast to ListPartsInput")?;
-287

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

@@ -179,179 +245,245 @@

↥ Expand context

             .downcast::<crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.account_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("account_id", "cannot be empty or unset"))?;
                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "account_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 ::std::write!(output, "/{accountId}/provisioned-capacity", accountId = account_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-205
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-214
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-219
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-221
+    }
-222
+}
 #[derive(Debug)]
 struct ListProvisionedCapacityEndpointParamsInterceptor;
-225

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListProvisionedCapacityEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListProvisionedCapacityEndpointParamsInterceptor"
-229
+    }
-230
     fn read_before_execution(
         &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::<ListProvisionedCapacityInput>()
             .ok_or("failed to downcast to ListProvisionedCapacityInput")?;
-245

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

@@ -196,196 +262,262 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-202
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-213
+                }
                 ::std::write!(
                     output,

                     "/{accountId}/vaults/{vaultName}/tags",
                     accountId = account_id,
                     vaultName = vault_name
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_tags_for_vault::ListTagsForVaultInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-231
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-236
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-238
+    }
-239
+}
 #[derive(Debug)]
 struct ListTagsForVaultEndpointParamsInterceptor;
-242

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTagsForVaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListTagsForVaultEndpointParamsInterceptor"
-246
+    }
-247
     fn read_before_execution(
         &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::<ListTagsForVaultInput>()
             .ok_or("failed to downcast to ListTagsForVaultInput")?;
-262

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

@@ -191,191 +258,258 @@

↥ Expand context

                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
-197
+                }
                 ::std::write!(output, "/{accountId}/vaults", accountId = account_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-200
+            }
             fn uri_query(
                 _input: &crate::operation::list_vaults::ListVaultsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
-207
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_2));
-209
+                    }
-210
+                }

                 if let ::std::option::Option::Some(inner_3) = &_input.limit {
-212
+                    {
                         query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
-214
+                    }
-215
+                }
                 ::std::result::Result::Ok(())
-217
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_vaults::ListVaultsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
-227
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-232
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-234
+    }
-235
+}
 #[derive(Debug)]
 struct ListVaultsEndpointParamsInterceptor;
-238

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListVaultsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListVaultsEndpointParamsInterceptor"
-242
+    }
-243
     fn read_before_execution(
         &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::<ListVaultsInput>()
             .ok_or("failed to downcast to ListVaultsInput")?;
-258

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

@@ -185,185 +251,251 @@

↥ Expand context

             .downcast::<crate::operation::purchase_provisioned_capacity::PurchaseProvisionedCapacityInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::purchase_provisioned_capacity::PurchaseProvisionedCapacityInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.account_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("account_id", "cannot be empty or unset"))?;
                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "account_id",
                         "cannot be empty or unset",
                     ));
-208
+                }
                 ::std::write!(output, "/{accountId}/provisioned-capacity", accountId = account_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-211
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::purchase_provisioned_capacity::PurchaseProvisionedCapacityInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-220
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-225
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-227
+    }
-228
+}
 #[derive(Debug)]
 struct PurchaseProvisionedCapacityEndpointParamsInterceptor;
-231

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PurchaseProvisionedCapacityEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PurchaseProvisionedCapacityEndpointParamsInterceptor"
-235
+    }
-236
     fn read_before_execution(
         &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::<PurchaseProvisionedCapacityInput>()
             .ok_or("failed to downcast to PurchaseProvisionedCapacityInput")?;
-251

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

@@ -204,204 +280,280 @@

↥ Expand context

                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
-213
+                }
                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/tags",
                     accountId = account_id,
                     vaultName = vault_name
-219
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-222
+            }
             fn uri_query(

                 _input: &crate::operation::remove_tags_from_vault::RemoveTagsFromVaultInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_kv("operation", "remove");
                 ::std::result::Result::Ok(())
-230
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::remove_tags_from_vault::RemoveTagsFromVaultInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-240
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_remove_tags_from_vault::ser_remove_tags_from_vault_input(
             &input,
         )?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-251
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-253
+    }
-254
+}
 #[derive(Debug)]
 struct RemoveTagsFromVaultEndpointParamsInterceptor;
-257
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RemoveTagsFromVaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RemoveTagsFromVaultEndpointParamsInterceptor"

↧ Expand context

-261
+    }
-262
     fn read_before_execution(
         &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::<RemoveTagsFromVaultInput>()
             .ok_or("failed to downcast to RemoveTagsFromVaultInput")?;
-277
         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))

AWS SDK

Files changed: