AWS SDK

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

@@ -201,201 +276,276 @@

                 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.dev_environment_id;
                 let input_3 = input_3.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("dev_environment_id", "cannot be empty or unset")
                 })?;
                 let dev_environment_id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if dev_environment_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "dev_environment_id",
                         "cannot be empty or unset",
                     ));
-217
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/devEnvironments/{devEnvironmentId}/sessions",

                     spaceName = space_name,
                     projectName = project_name,
                     devEnvironmentId = dev_environment_id
-224
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-227
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_dev_environment_sessions::ListDevEnvironmentSessionsInput,
                 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))
-236
+            }
             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_dev_environment_sessions::ser_list_dev_environment_sessions_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);
-247
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-249
+    }
-250
+}
 #[derive(Debug)]
 struct ListDevEnvironmentSessionsEndpointParamsInterceptor;
-253
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListDevEnvironmentSessionsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListDevEnvironmentSessionsEndpointParamsInterceptor"

↧ Expand context

-257
+    }
-258
     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::<ListDevEnvironmentSessionsInput>()
             .ok_or("failed to downcast to ListDevEnvironmentSessionsInput")?;
-273
         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/list_dev_environments.rs

@@ -166,166 +241,241 @@

↥ Expand context

             .downcast::<crate::operation::list_dev_environments::ListDevEnvironmentsInput>()
             .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_dev_environments::ListDevEnvironmentsInput,
                 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}/devEnvironments", spaceName = space_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-192
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_dev_environments::ListDevEnvironmentsInput,
                 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))
-201
+            }
             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_dev_environments::ser_list_dev_environments_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);
-212
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-214
+    }
-215
+}
 #[derive(Debug)]
 struct ListDevEnvironmentsEndpointParamsInterceptor;
-218
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListDevEnvironmentsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListDevEnvironmentsEndpointParamsInterceptor"

↧ Expand context

-222
+    }
-223
     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::<ListDevEnvironmentsInput>()
             .ok_or("failed to downcast to ListDevEnvironmentsInput")?;
-238
         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/list_event_logs.rs

@@ -166,166 +239,239 @@

↥ Expand context

             .downcast::<crate::operation::list_event_logs::ListEventLogsInput>()
             .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_event_logs::ListEventLogsInput,
                 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}/eventLogs", spaceName = space_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-192
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_event_logs::ListEventLogsInput,
                 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))
-201
+            }
             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_event_logs::ser_list_event_logs_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);
-210
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-212
+    }
-213
+}
 #[derive(Debug)]
 struct ListEventLogsEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListEventLogsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListEventLogsEndpointParamsInterceptor"

↧ Expand context

-220
+    }
-221
     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::<ListEventLogsInput>()
             .ok_or("failed to downcast to ListEventLogsInput")?;
-236
         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/list_projects.rs

@@ -166,166 +239,239 @@

↥ Expand context

             .downcast::<crate::operation::list_projects::ListProjectsInput>()
             .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_projects::ListProjectsInput,
                 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}/projects", spaceName = space_name).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-192
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_projects::ListProjectsInput,
                 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))
-201
+            }
             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_projects::ser_list_projects_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);
-210
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-212
+    }
-213
+}
 #[derive(Debug)]
 struct ListProjectsEndpointParamsInterceptor;
-216
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListProjectsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListProjectsEndpointParamsInterceptor"

↧ Expand context

-220
+    }
-221
     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::<ListProjectsInput>()
             .ok_or("failed to downcast to ListProjectsInput")?;
-236
         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/list_source_repositories.rs

@@ -189,189 +264,264 @@

↥ Expand context

                 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",
                     ));
-195
+                }
                 let input_2 = &_input.project_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("project_name", "cannot be empty or unset"))?;
                 let project_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 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
+                }
                 ::std::write!(
                     output,

                     "/v1/spaces/{spaceName}/projects/{projectName}/sourceRepositories",
                     spaceName = space_name,
                     projectName = project_name
-212
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-215
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_source_repositories::ListSourceRepositoriesInput,
                 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))
-224
+            }
             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_source_repositories::ser_list_source_repositories_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);
-235
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-237
+    }
-238
+}
 #[derive(Debug)]
 struct ListSourceRepositoriesEndpointParamsInterceptor;
-241
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListSourceRepositoriesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListSourceRepositoriesEndpointParamsInterceptor"

↧ Expand context

-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::<ListSourceRepositoriesInput>()
             .ok_or("failed to downcast to ListSourceRepositoriesInput")?;
-261
         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/list_source_repository_branches.rs

@@ -201,201 +276,276 @@

↥ 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}/branches",

                     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::list_source_repository_branches::ListSourceRepositoryBranchesInput,
                 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))
-236
+            }
             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_source_repository_branches::ser_list_source_repository_branches_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);
-247
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-249
+    }
-250
+}
 #[derive(Debug)]
 struct ListSourceRepositoryBranchesEndpointParamsInterceptor;
-253
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListSourceRepositoryBranchesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListSourceRepositoryBranchesEndpointParamsInterceptor"

↧ Expand context

-257
+    }
-258
     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::<ListSourceRepositoryBranchesInput>()
             .ok_or("failed to downcast to ListSourceRepositoryBranchesInput")?;
-273
         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/list_spaces.rs

@@ -153,153 +226,226 @@

↥ Expand context

         crate::protocol_serde::type_erase_result(parse_result)
-154
+    }
-155
+}
 #[derive(Debug)]
 struct ListSpacesRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListSpacesRequestSerializer {
     #[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_spaces::ListSpacesInput>().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_spaces::ListSpacesInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/v1/spaces").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-179
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_spaces::ListSpacesInput,
                 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))
-188
+            }
             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_spaces::ser_list_spaces_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);
-197
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-199
+    }
-200
+}
 #[derive(Debug)]
 struct ListSpacesEndpointParamsInterceptor;
-203
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListSpacesEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListSpacesEndpointParamsInterceptor"

↧ Expand context

-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::<ListSpacesInput>()
             .ok_or("failed to downcast to ListSpacesInput")?;
-223
         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/list_workflow_runs.rs

@@ -205,205 +279,279 @@

↥ Expand context

                     projectName = project_name
-206
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-209
+            }
             fn uri_query(
                 _input: &crate::operation::list_workflow_runs::ListWorkflowRunsInput,
                 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.workflow_id {
-216
+                    {
                         query.push_kv("workflowId", &::aws_smithy_http::query::fmt_string(inner_3));
-218
+                    }
-219
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.next_token {
-221
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_4));
-223
+                    }
-224
+                }

                 if let ::std::option::Option::Some(inner_5) = &_input.max_results {
-226
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
-228
+                    }
-229
+                }
                 ::std::result::Result::Ok(())
-231
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_workflow_runs::ListWorkflowRunsInput,
                 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))
-241
+            }
             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_workflow_runs::ser_list_workflow_runs_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);
-250
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-252
+    }
-253
+}
 #[derive(Debug)]
 struct ListWorkflowRunsEndpointParamsInterceptor;
-256
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListWorkflowRunsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListWorkflowRunsEndpointParamsInterceptor"

↧ Expand context

-260
+    }
-261
     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::<ListWorkflowRunsInput>()
             .ok_or("failed to downcast to ListWorkflowRunsInput")?;
-276
         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/list_workflows.rs

@@ -200,200 +274,274 @@

↥ Expand context

-200
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/workflows",
                     spaceName = space_name,
                     projectName = project_name
-206
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-209
+            }
             fn uri_query(
                 _input: &crate::operation::list_workflows::ListWorkflowsInput,
                 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.next_token {
-216
+                    {
                         query.push_kv("nextToken", &::aws_smithy_http::query::fmt_string(inner_3));
-218
+                    }
-219
+                }

                 if let ::std::option::Option::Some(inner_4) = &_input.max_results {
-221
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_4).encode());
-223
+                    }
-224
+                }
                 ::std::result::Result::Ok(())
-226
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_workflows::ListWorkflowsInput,
                 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))
-236
+            }
             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_workflows::ser_list_workflows_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);
-245
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-247
+    }
-248
+}
 #[derive(Debug)]
 struct ListWorkflowsEndpointParamsInterceptor;
-251
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListWorkflowsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListWorkflowsEndpointParamsInterceptor"

↧ Expand context

-255
+    }
-256
     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::<ListWorkflowsInput>()
             .ok_or("failed to downcast to ListWorkflowsInput")?;
-271
         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/start_dev_environment.rs

@@ -195,195 +270,270 @@

↥ 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}/start",

                     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::start_dev_environment::StartDevEnvironmentInput,
                 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))
-230
+            }
             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_start_dev_environment::ser_start_dev_environment_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);
-241
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-243
+    }
-244
+}
 #[derive(Debug)]
 struct StartDevEnvironmentEndpointParamsInterceptor;
-247
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartDevEnvironmentEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartDevEnvironmentEndpointParamsInterceptor"

↧ Expand context

-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::<StartDevEnvironmentInput>()
             .ok_or("failed to downcast to StartDevEnvironmentInput")?;
-267
         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/start_dev_environment_session.rs

@@ -202,202 +277,277 @@

↥ 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",
                     ));
-207
+                }
                 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",
                     ));
-218
+                }
                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/devEnvironments/{id}/session",

                     spaceName = space_name,
                     projectName = project_name,
                     id = id
-225
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-228
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_dev_environment_session::StartDevEnvironmentSessionInput,
                 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))
-237
+            }
             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_start_dev_environment_session::ser_start_dev_environment_session_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);
-248
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-250
+    }
-251
+}
 #[derive(Debug)]
 struct StartDevEnvironmentSessionEndpointParamsInterceptor;
-254
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartDevEnvironmentSessionEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartDevEnvironmentSessionEndpointParamsInterceptor"

↧ Expand context

-258
+    }
-259
     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::<StartDevEnvironmentSessionInput>()
             .ok_or("failed to downcast to StartDevEnvironmentSessionInput")?;
-274
         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/start_workflow_run.rs

@@ -208,208 +282,282 @@

↥ Expand context

                 ::std::write!(
                     output,
                     "/v1/spaces/{spaceName}/projects/{projectName}/workflowRuns",
                     spaceName = space_name,
                     projectName = project_name
-213
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-216
+            }
             fn uri_query(
                 _input: &crate::operation::start_workflow_run::StartWorkflowRunInput,
                 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);
                 let inner_3 = &_input.workflow_id;
                 let inner_3 = inner_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("workflow_id", "cannot be empty or unset"))?;
                 if inner_3.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "workflow_id",
                         "cannot be empty or unset",
                     ));
-231
+                }
                 query.push_kv("workflowId", &::aws_smithy_http::query::fmt_string(inner_3));
                 ::std::result::Result::Ok(())
-234
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_workflow_run::StartWorkflowRunInput,
                 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("PUT").uri(uri))
-244
+            }
             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_start_workflow_run::ser_start_workflow_run_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);
-253
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-255
+    }
-256
+}
 #[derive(Debug)]
 struct StartWorkflowRunEndpointParamsInterceptor;
-259
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartWorkflowRunEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartWorkflowRunEndpointParamsInterceptor"

↧ Expand context

-263
+    }
-264
     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::<StartWorkflowRunInput>()
             .ok_or("failed to downcast to StartWorkflowRunInput")?;
-279
         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/stop_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}/stop",

                     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::stop_dev_environment::StopDevEnvironmentInput,
                 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))
-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 StopDevEnvironmentEndpointParamsInterceptor;
-241

↧ Expand context

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

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

@@ -213,213 +279,279 @@

↥ Expand context

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

                     projectName = project_name,
                     id = id,
                     sessionId = session_id
-236
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-239
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::stop_dev_environment_session::StopDevEnvironmentSessionInput,
                 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))
-248
+            }
             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("");
-253
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-255
+    }
-256
+}
 #[derive(Debug)]
 struct StopDevEnvironmentSessionEndpointParamsInterceptor;
-259

↧ Expand context

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

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

@@ -195,195 +270,270 @@

↥ 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::update_dev_environment::UpdateDevEnvironmentInput,
                 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("PATCH").uri(uri))
-230
+            }
             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_update_dev_environment::ser_update_dev_environment_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);
-241
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-243
+    }
-244
+}
 #[derive(Debug)]
 struct UpdateDevEnvironmentEndpointParamsInterceptor;
-247
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateDevEnvironmentEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateDevEnvironmentEndpointParamsInterceptor"

↧ Expand context

-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::<UpdateDevEnvironmentInput>()
             .ok_or("failed to downcast to UpdateDevEnvironmentInput")?;
-267
         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/update_project.rs

@@ -178,178 +251,251 @@

↥ 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::update_project::UpdateProjectInput,
                 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("PATCH").uri(uri))
-213
+            }
             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_update_project::ser_update_project_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);
-222
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-224
+    }
-225
+}
 #[derive(Debug)]
 struct UpdateProjectEndpointParamsInterceptor;
-228
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateProjectEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateProjectEndpointParamsInterceptor"

↧ Expand context

-232
+    }
-233
     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::<UpdateProjectInput>()
             .ok_or("failed to downcast to UpdateProjectInput")?;
-248
         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: