AWS SDK

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/create_source_repository_branch.rs

@@ -213,213 +288,288 @@

                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "source_repository_name",
                         "cannot be empty or unset",
                     ));
-217
+                }
                 let input_4 = &_input.name;
                 let input_4 = input_4
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_4, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "name",
                         "cannot be empty or unset",
                     ));
-228
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/sourceRepositories/{sourceRepositoryName}/branches/{name}",
                     spaceName = space_name,

                     projectName = project_name,
                     sourceRepositoryName = source_repository_name,
                     name = name
-236
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-239
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::create_source_repository_branch::CreateSourceRepositoryBranchInput,
                 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("PUT").uri(uri))
-248
+            }
             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_create_source_repository_branch::ser_create_source_repository_branch_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);
-259
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-261
+    }
-262
+}
 #[derive(Debug)]
 struct CreateSourceRepositoryBranchEndpointParamsInterceptor;
-265
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateSourceRepositoryBranchEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CreateSourceRepositoryBranchEndpointParamsInterceptor"

↧ Expand context

-269
+    }
-270
     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::<CreateSourceRepositoryBranchInput>()
             .ok_or("failed to downcast to CreateSourceRepositoryBranchInput")?;
-285
         let params = crate::config::endpoint::Params::builder()
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/delete_access_token.rs

@@ -166,166 +232,232 @@

↥ Expand context

             .downcast::<crate::operation::delete_access_token::DeleteAccessTokenInput>()
             .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::delete_access_token::DeleteAccessTokenInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 let id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "id",
                         "cannot be empty or unset",
                     ));
-189
+                }
                 ::std::write!(output, "/v1/accessTokens/{id}", id = id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-192
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_access_token::DeleteAccessTokenInput,
                 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("DELETE").uri(uri))
-201
+            }
             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("");
-206
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-208
+    }
-209
+}
 #[derive(Debug)]
 struct DeleteAccessTokenEndpointParamsInterceptor;
-212

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteAccessTokenEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteAccessTokenEndpointParamsInterceptor"
-216
+    }
-217
     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::<DeleteAccessTokenInput>()
             .ok_or("failed to downcast to DeleteAccessTokenInput")?;
-232

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/delete_dev_environment.rs

@@ -195,195 +261,261 @@

↥ Expand context

                 if project_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "project_name",
                         "cannot be empty or unset",
                     ));
-200
+                }
                 let input_3 = &_input.id;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 let id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "id",
                         "cannot be empty or unset",
                     ));
-211
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/devEnvironments/{id}",

                     spaceName = space_name,
                     projectName = project_name,
                     id = id
-218
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-221
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_dev_environment::DeleteDevEnvironmentInput,
                 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("DELETE").uri(uri))
-230
+            }
             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("");
-235
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-237
+    }
-238
+}
 #[derive(Debug)]
 struct DeleteDevEnvironmentEndpointParamsInterceptor;
-241

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/delete_project.rs

@@ -178,178 +244,244 @@

↥ Expand context

                 use ::std::fmt::Write as _;
                 let input_1 = &_input.space_name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("space_name", "cannot be empty or unset"))?;
                 let space_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if space_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "space_name",
                         "cannot be empty or unset",
                     ));
-189
+                }
                 let input_2 = &_input.name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "name",

                         "cannot be empty or unset",
                     ));
-200
+                }
                 ::std::write!(output, "/v1/spaces/{spaceName}/projects/{name}", spaceName = space_name, name = name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-204
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_project::DeleteProjectInput,
                 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("DELETE").uri(uri))
-213
+            }
             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("");
-218
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-220
+    }
-221
+}
 #[derive(Debug)]
 struct DeleteProjectEndpointParamsInterceptor;
-224

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/delete_source_repository.rs

@@ -201,201 +267,267 @@

↥ Expand context

                 if project_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "project_name",
                         "cannot be empty or unset",
                     ));
-206
+                }
                 let input_3 = &_input.name;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "name",
                         "cannot be empty or unset",
                     ));
-217
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/sourceRepositories/{name}",

                     spaceName = space_name,
                     projectName = project_name,
                     name = name
-224
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-227
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_source_repository::DeleteSourceRepositoryInput,
                 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("DELETE").uri(uri))
-236
+            }
             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("");
-241
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-243
+    }
-244
+}
 #[derive(Debug)]
 struct DeleteSourceRepositoryEndpointParamsInterceptor;
-247

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/delete_space.rs

@@ -166,166 +232,232 @@

↥ Expand context

             .downcast::<crate::operation::delete_space::DeleteSpaceInput>()
             .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::delete_space::DeleteSpaceInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "name",
                         "cannot be empty or unset",
                     ));
-189
+                }
                 ::std::write!(output, "/v1/spaces/{name}", name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-192
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::delete_space::DeleteSpaceInput,
                 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("DELETE").uri(uri))
-201
+            }
             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("");
-206
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-208
+    }
-209
+}
 #[derive(Debug)]
 struct DeleteSpaceEndpointParamsInterceptor;
-212

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteSpaceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "DeleteSpaceEndpointParamsInterceptor"
-216
+    }
-217
     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::<DeleteSpaceInput>()
             .ok_or("failed to downcast to DeleteSpaceInput")?;
-232

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_dev_environment.rs

@@ -195,195 +261,261 @@

↥ Expand context

                 if project_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "project_name",
                         "cannot be empty or unset",
                     ));
-200
+                }
                 let input_3 = &_input.id;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 let id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "id",
                         "cannot be empty or unset",
                     ));
-211
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/devEnvironments/{id}",

                     spaceName = space_name,
                     projectName = project_name,
                     id = id
-218
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-221
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_dev_environment::GetDevEnvironmentInput,
                 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))
-230
+            }
             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("");
-235
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-237
+    }
-238
+}
 #[derive(Debug)]
 struct GetDevEnvironmentEndpointParamsInterceptor;
-241

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_project.rs

@@ -176,176 +242,242 @@

↥ Expand context

                 use ::std::fmt::Write as _;
                 let input_1 = &_input.space_name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("space_name", "cannot be empty or unset"))?;
                 let space_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if space_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "space_name",
                         "cannot be empty or unset",
                     ));
-187
+                }
                 let input_2 = &_input.name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "name",

                         "cannot be empty or unset",
                     ));
-198
+                }
                 ::std::write!(output, "/v1/spaces/{spaceName}/projects/{name}", spaceName = space_name, name = name)
                     .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-202
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_project::GetProjectInput,
                 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))
-211
+            }
             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("");
-216
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-218
+    }
-219
+}
 #[derive(Debug)]
 struct GetProjectEndpointParamsInterceptor;
-222

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_source_repository.rs

@@ -195,195 +261,261 @@

↥ Expand context

                 if project_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "project_name",
                         "cannot be empty or unset",
                     ));
-200
+                }
                 let input_3 = &_input.name;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "name",
                         "cannot be empty or unset",
                     ));
-211
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/sourceRepositories/{name}",

                     spaceName = space_name,
                     projectName = project_name,
                     name = name
-218
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-221
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_source_repository::GetSourceRepositoryInput,
                 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))
-230
+            }
             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("");
-235
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-237
+    }
-238
+}
 #[derive(Debug)]
 struct GetSourceRepositoryEndpointParamsInterceptor;
-241

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_source_repository_clone_urls.rs

@@ -201,201 +267,267 @@

↥ Expand context

                 if project_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "project_name",
                         "cannot be empty or unset",
                     ));
-206
+                }
                 let input_3 = &_input.source_repository_name;
                 let input_3 = input_3.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("source_repository_name", "cannot be empty or unset")
                 })?;
                 let source_repository_name = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if source_repository_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "source_repository_name",
                         "cannot be empty or unset",
                     ));
-217
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/sourceRepositories/{sourceRepositoryName}/cloneUrls",

                     spaceName = space_name,
                     projectName = project_name,
                     sourceRepositoryName = source_repository_name
-224
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-227
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_source_repository_clone_urls::GetSourceRepositoryCloneUrlsInput,
                 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))
-236
+            }
             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("");
-241
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-243
+    }
-244
+}
 #[derive(Debug)]
 struct GetSourceRepositoryCloneUrlsEndpointParamsInterceptor;
-247

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_space.rs

@@ -157,157 +223,223 @@

↥ Expand context

     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::get_space::GetSpaceInput>().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_space::GetSpaceInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("name", "cannot be empty or unset"))?;
                 let name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "name",
                         "cannot be empty or unset",
                     ));
-180
+                }
                 ::std::write!(output, "/v1/spaces/{name}", name = name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-183
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_space::GetSpaceInput,
                 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))
-192
+            }
             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("");
-197
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct GetSpaceEndpointParamsInterceptor;
-203

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetSpaceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetSpaceEndpointParamsInterceptor"
-207
+    }
-208
     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::<GetSpaceInput>()
             .ok_or("failed to downcast to GetSpaceInput")?;
-223

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_subscription.rs

@@ -166,166 +232,232 @@

↥ Expand context

             .downcast::<crate::operation::get_subscription::GetSubscriptionInput>()
             .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_subscription::GetSubscriptionInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.space_name;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("space_name", "cannot be empty or unset"))?;
                 let space_name = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if space_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "space_name",
                         "cannot be empty or unset",
                     ));
-189
+                }
                 ::std::write!(output, "/v1/spaces/{spaceName}/subscription", spaceName = space_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-192
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_subscription::GetSubscriptionInput,
                 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))
-201
+            }
             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("");
-206
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-208
+    }
-209
+}
 #[derive(Debug)]
 struct GetSubscriptionEndpointParamsInterceptor;
-212

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetSubscriptionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetSubscriptionEndpointParamsInterceptor"
-216
+    }
-217
     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::<GetSubscriptionInput>()
             .ok_or("failed to downcast to GetSubscriptionInput")?;
-232

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_user_details.rs

@@ -172,172 +239,239 @@

↥ Expand context

         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::get_user_details::GetUserDetailsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/userDetails").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-181
+            }
             fn uri_query(
                 _input: &crate::operation::get_user_details::GetUserDetailsInput,
                 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_1) = &_input.id {
-188
+                    {
                         query.push_kv("id", &::aws_smithy_http::query::fmt_string(inner_1));
-190
+                    }
-191
+                }

                 if let ::std::option::Option::Some(inner_2) = &_input.user_name {
-193
+                    {
                         query.push_kv("userName", &::aws_smithy_http::query::fmt_string(inner_2));
-195
+                    }
-196
+                }
                 ::std::result::Result::Ok(())
-198
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_user_details::GetUserDetailsInput,
                 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))
-208
+            }
             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("");
-213
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-215
+    }
-216
+}
 #[derive(Debug)]
 struct GetUserDetailsEndpointParamsInterceptor;
-219

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetUserDetailsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetUserDetailsEndpointParamsInterceptor"
-223
+    }
-224
     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::<GetUserDetailsInput>()
             .ok_or("failed to downcast to GetUserDetailsInput")?;
-239

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_workflow.rs

@@ -195,195 +261,261 @@

↥ Expand context

                 if project_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "project_name",
                         "cannot be empty or unset",
                     ));
-200
+                }
                 let input_3 = &_input.id;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 let id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "id",
                         "cannot be empty or unset",
                     ));
-211
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/workflows/{id}",

                     spaceName = space_name,
                     projectName = project_name,
                     id = id
-218
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-221
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_workflow::GetWorkflowInput,
                 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))
-230
+            }
             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("");
-235
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-237
+    }
-238
+}
 #[derive(Debug)]
 struct GetWorkflowEndpointParamsInterceptor;
-241

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/get_workflow_run.rs

@@ -195,195 +261,261 @@

↥ Expand context

                 if project_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "project_name",
                         "cannot be empty or unset",
                     ));
-200
+                }
                 let input_3 = &_input.id;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
                 let id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "id",
                         "cannot be empty or unset",
                     ));
-211
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/workflowRuns/{id}",

                     spaceName = space_name,
                     projectName = project_name,
                     id = id
-218
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-221
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_workflow_run::GetWorkflowRunInput,
                 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))
-230
+            }
             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("");
-235
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-237
+    }
-238
+}
 #[derive(Debug)]
 struct GetWorkflowRunEndpointParamsInterceptor;
-241

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/codecatalyst/src/operation/list_access_tokens.rs

@@ -155,155 +228,228 @@

↥ Expand context

-155
+}
 #[derive(Debug)]
 struct ListAccessTokensRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListAccessTokensRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::list_access_tokens::ListAccessTokensInput>()
             .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_access_tokens::ListAccessTokensInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v1/accessTokens").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-181
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_access_tokens::ListAccessTokensInput,
                 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))
-190
+            }
             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_list_access_tokens::ser_list_access_tokens_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);
-199
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-201
+    }
-202
+}
 #[derive(Debug)]
 struct ListAccessTokensEndpointParamsInterceptor;
-205
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListAccessTokensEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListAccessTokensEndpointParamsInterceptor"

↧ Expand context

-209
+    }
-210
     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::<ListAccessTokensInput>()
             .ok_or("failed to downcast to ListAccessTokensInput")?;
-225
         let params = crate::config::endpoint::Params::builder()
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))

AWS SDK

Files changed: