AWS SDK

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/test_transformer.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `TestTransformer`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct TestTransformer;
 impl TestTransformer {
     /// Creates a new `TestTransformer`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_transformer::TestTransformerInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::test_transformer::TestTransformerOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::test_transformer::TestTransformerInput,
     ) -> ::std::result::Result<
         crate::operation::test_transformer::TestTransformerOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::test_transformer::TestTransformerError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::test_transformer::TestTransformerError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::test_transformer::TestTransformerOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +245,334 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("TestTransformer")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(TestTransformerEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::test_transformer::TestTransformerError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::test_transformer::TestTransformerError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::test_transformer::TestTransformerError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct TestTransformerResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestTransformerResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_test_transformer::de_test_transformer_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::test_transformer::TestTransformerError::unhandled(
                             generic,
                         )),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InvalidOperationException" => crate::operation::test_transformer::TestTransformerError::InvalidOperationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidOperationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidOperationException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidParameterException" => crate::operation::test_transformer::TestTransformerError::InvalidParameterException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidParameterException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidParameterException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::test_transformer::TestTransformerError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::test_transformer::TestTransformerError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_test_transformer::de_test_transformer_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, TestTransformer::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::test_transformer::TestTransformerOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-283
+    }
-284
+}
 #[derive(Debug)]
 struct TestTransformerRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestTransformerRequestSerializer {
     #[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::test_transformer::TestTransformerInput>()
             .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::test_transformer::TestTransformerInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::test_transformer::TestTransformerInput,
                 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))
--
+            }
             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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "Logs_20140328.TestTransformer",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_test_transformer::ser_test_transformer_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_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, TestTransformer::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-305
+    }
-306
+}
 #[derive(Debug)]
 struct TestTransformerEndpointParamsInterceptor;
-309
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for TestTransformerEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "TestTransformerEndpointParamsInterceptor"
-313
+    }
-314

↧ Expand context

     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::<TestTransformerInput>()
             .ok_or("failed to downcast to TestTransformerInput")?;
-329
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/test_transformer/_test_transformer_input.rs

@@ -7,7 +173,173 @@

↥ Expand context

     pub transformer_config: ::std::option::Option<::std::vec::Vec<crate::types::Processor>>,
     /// <p>An array of the raw log events that you want to use to test this transformer.</p>
     pub log_event_messages: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-10
+}
 impl TestTransformerInput {
     /// <p>This structure contains the configuration of this log transformer that you want to test. A log transformer is an array of processors, where each processor applies one type of transformation to the log events that are ingested.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.transformer_config.is_none()`.
     pub fn transformer_config(&self) -> &[crate::types::Processor] {
         self.transformer_config.as_deref().unwrap_or_default()
-17
+    }
     /// <p>An array of the raw log events that you want to use to test this transformer.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.log_event_messages.is_none()`.
     pub fn log_event_messages(&self) -> &[::std::string::String] {
         self.log_event_messages.as_deref().unwrap_or_default()
-23
+    }
-24
+}
 static TESTTRANSFORMERINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#TestTransformerInput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "TestTransformerInput",
 );
 static TESTTRANSFORMERINPUT_MEMBER_TRANSFORMER_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#TestTransformerInput$transformerConfig",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "TestTransformerInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "transformer_config",
     "transformerConfig",
 ,
 );
 static TESTTRANSFORMERINPUT_MEMBER_LOG_EVENT_MESSAGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#TestTransformerInput$logEventMessages",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "TestTransformerInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "log_event_messages",
     "logEventMessages",
 ,
 );
 static TESTTRANSFORMERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TESTTRANSFORMERINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &TESTTRANSFORMERINPUT_MEMBER_TRANSFORMER_CONFIG,
         &TESTTRANSFORMERINPUT_MEMBER_LOG_EVENT_MESSAGES,
     ],
 );
 impl TestTransformerInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTTRANSFORMERINPUT_SCHEMA;
-61
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestTransformerInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.transformer_config {
             ser.write_list(
                 &TESTTRANSFORMERINPUT_MEMBER_TRANSFORMER_CONFIG,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Processor::SCHEMA, item)?;
-74
+                    }
                     Ok(())
                 },
             )?;
-78
+        }
         if let Some(ref val) = self.log_event_messages {
             ser.write_list(
                 &TESTTRANSFORMERINPUT_MEMBER_LOG_EVENT_MESSAGES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-85
+                    }
                     Ok(())
                 },
             )?;
-89
+        }
         Ok(())
-91
+    }
-92
+}
 impl TestTransformerInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&TESTTRANSFORMERINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTTRANSFORMERINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.transformer_config = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Processor::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Processor::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-118
+                }
                 Some(1) => {
                     builder.log_event_messages = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.log_event_messages = Some(deser.read_string_list(member)?);
-121
+                }
                 _ => {}
-123
+            }
             Ok(())
         })?;
         builder.transformer_config = builder.transformer_config.or(Some(Vec::new()));
         builder.log_event_messages = builder.log_event_messages.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-131
+    }
-132
+}
 impl TestTransformerInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl TestTransformerInput {
     /// Creates a new builder-style object to manufacture [`TestTransformerInput`](crate::operation::test_transformer::TestTransformerInput).
     pub fn builder() -> crate::operation::test_transformer::builders::TestTransformerInputBuilder {
         crate::operation::test_transformer::builders::TestTransformerInputBuilder::default()
-148
+    }
-149
+}
-150
 /// A builder for [`TestTransformerInput`](crate::operation::test_transformer::TestTransformerInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TestTransformerInputBuilder {
     pub(crate) transformer_config: ::std::option::Option<::std::vec::Vec<crate::types::Processor>>,
     pub(crate) log_event_messages: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-157
+}
 impl TestTransformerInputBuilder {
     /// Appends an item to `transformer_config`.
     ///
     /// To override the contents of this collection use [`set_transformer_config`](Self::set_transformer_config).
     ///
     /// <p>This structure contains the configuration of this log transformer that you want to test. A log transformer is an array of processors, where each processor applies one type of transformation to the log events that are ingested.</p>
     pub fn transformer_config(mut self, input: crate::types::Processor) -> Self {
         let mut v = self.transformer_config.unwrap_or_default();
         v.push(input);
         self.transformer_config = ::std::option::Option::Some(v);
         self
-169
+    }
     /// <p>This structure contains the configuration of this log transformer that you want to test. A log transformer is an array of processors, where each processor applies one type of transformation to the log events that are ingested.</p>
     pub fn set_transformer_config(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Processor>>) -> Self {
         self.transformer_config = input;
         self

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/test_transformer/_test_transformer_output.rs

@@ -1,1 +118,166 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct TestTransformerOutput {
     /// <p>An array where each member of the array includes both the original version and the transformed version of one of the log events that you input.</p>
     pub transformed_logs: ::std::option::Option<::std::vec::Vec<crate::types::TransformedLogRecord>>,
     _request_id: Option<String>,
-9
+}
 impl TestTransformerOutput {
     /// <p>An array where each member of the array includes both the original version and the transformed version of one of the log events that you input.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.transformed_logs.is_none()`.
     pub fn transformed_logs(&self) -> &[crate::types::TransformedLogRecord] {
         self.transformed_logs.as_deref().unwrap_or_default()
-16
+    }
-17
+}
 static TESTTRANSFORMEROUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#TestTransformerOutput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "TestTransformerOutput",
 );
 static TESTTRANSFORMEROUTPUT_MEMBER_TRANSFORMED_LOGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#TestTransformerOutput$transformedLogs",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "TestTransformerOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "transformed_logs",
     "transformedLogs",
 ,
 );
 static TESTTRANSFORMEROUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static TESTTRANSFORMEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TESTTRANSFORMEROUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&TESTTRANSFORMEROUTPUT_MEMBER_TRANSFORMED_LOGS],
     &[&TESTTRANSFORMEROUTPUT_MEMBER_TRANSFORMED_LOGS, &TESTTRANSFORMEROUTPUT_MEMBER__REQUEST_ID],
 );
 impl TestTransformerOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTTRANSFORMEROUTPUT_SCHEMA;
-48
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestTransformerOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.transformed_logs {
             ser.write_list(
                 &TESTTRANSFORMEROUTPUT_MEMBER_TRANSFORMED_LOGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TransformedLogRecord::SCHEMA, item)?;
-61
+                    }
                     Ok(())
                 },
             )?;
-65
+        }
         Ok(())
-67
+    }
-68
+}
 impl TestTransformerOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&TESTTRANSFORMEROUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTTRANSFORMEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.transformed_logs = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::TransformedLogRecord::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TransformedLogRecord::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl TestTransformerOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&TESTTRANSFORMEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.transformed_logs = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TransformedLogRecord::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-138
+                }
                 _ => {}
-140
+            }
             Ok(())
         })?;
         Ok(builder.build())
-144
+    }
-145
+}
 impl ::aws_types::request_id::RequestId for TestTransformerOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-149
+    }
-150
+}
 impl TestTransformerOutput {
     /// Creates a new builder-style object to manufacture [`TestTransformerOutput`](crate::operation::test_transformer::TestTransformerOutput).
     pub fn builder() -> crate::operation::test_transformer::builders::TestTransformerOutputBuilder {
         crate::operation::test_transformer::builders::TestTransformerOutputBuilder::default()
-155
+    }
-156
+}
-157
 /// A builder for [`TestTransformerOutput`](crate::operation::test_transformer::TestTransformerOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct TestTransformerOutputBuilder {
     pub(crate) transformed_logs: ::std::option::Option<::std::vec::Vec<crate::types::TransformedLogRecord>>,
     _request_id: Option<String>,
-164
+}
 impl TestTransformerOutputBuilder {
     /// Appends an item to `transformed_logs`.

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/untag_log_group.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `UntagLogGroup`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UntagLogGroup;
 impl UntagLogGroup {
     /// Creates a new `UntagLogGroup`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::untag_log_group::UntagLogGroupInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::untag_log_group::UntagLogGroupOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::untag_log_group::UntagLogGroupInput,
     ) -> ::std::result::Result<
         crate::operation::untag_log_group::UntagLogGroupOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::untag_log_group::UntagLogGroupError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::untag_log_group::UntagLogGroupError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::untag_log_group::UntagLogGroupOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +245,284 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UntagLogGroup")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UntagLogGroupEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::untag_log_group::UntagLogGroupError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::untag_log_group::UntagLogGroupError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::untag_log_group::UntagLogGroupError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UntagLogGroupResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UntagLogGroupResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_untag_log_group::de_untag_log_group_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::untag_log_group::UntagLogGroupError::unhandled(
                             generic,
                         )),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "ResourceNotFoundException" => crate::operation::untag_log_group::UntagLogGroupError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::untag_log_group::UntagLogGroupError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_untag_log_group::de_untag_log_group_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, UntagLogGroup::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::untag_log_group::UntagLogGroupOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-233
+    }
-234
+}
 #[derive(Debug)]
 struct UntagLogGroupRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UntagLogGroupRequestSerializer {
     #[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::untag_log_group::UntagLogGroupInput>()
             .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::untag_log_group::UntagLogGroupInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::untag_log_group::UntagLogGroupInput,
                 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))
--
+            }
             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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "Logs_20140328.UntagLogGroup",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_untag_log_group::ser_untag_log_group_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_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, UntagLogGroup::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-255
+    }
-256
+}
 #[derive(Debug)]
 struct UntagLogGroupEndpointParamsInterceptor;
-259
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UntagLogGroupEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UntagLogGroupEndpointParamsInterceptor"
-263
+    }
-264

↧ Expand context

     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::<UntagLogGroupInput>()
             .ok_or("failed to downcast to UntagLogGroupInput")?;
-279
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/untag_log_group/_untag_log_group_input.rs

@@ -6,6 +151,154 @@

↥ Expand context

 pub struct UntagLogGroupInput {
     /// <p>The name of the log group.</p>
     pub log_group_name: ::std::option::Option<::std::string::String>,
     /// <p>The tag keys. The corresponding tags are removed from the log group.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-11
+}
 impl UntagLogGroupInput {
     /// <p>The name of the log group.</p>
     pub fn log_group_name(&self) -> ::std::option::Option<&str> {
         self.log_group_name.as_deref()
-16
+    }
     /// <p>The tag keys. The corresponding tags are removed from the log group.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[::std::string::String] {
         self.tags.as_deref().unwrap_or_default()
-22
+    }
-23
+}
 static UNTAGLOGGROUPINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#UntagLogGroupInput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "UntagLogGroupInput",
 );
 static UNTAGLOGGROUPINPUT_MEMBER_LOG_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UntagLogGroupInput$logGroupName",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UntagLogGroupInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "log_group_name",
     "logGroupName",
 ,
 );
 static UNTAGLOGGROUPINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UntagLogGroupInput$tags",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UntagLogGroupInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
 ,
 );
 static UNTAGLOGGROUPINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UNTAGLOGGROUPINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UNTAGLOGGROUPINPUT_MEMBER_LOG_GROUP_NAME, &UNTAGLOGGROUPINPUT_MEMBER_TAGS],
 );
 impl UntagLogGroupInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UNTAGLOGGROUPINPUT_SCHEMA;
-57
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UntagLogGroupInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.log_group_name {
             ser.write_string(&UNTAGLOGGROUPINPUT_MEMBER_LOG_GROUP_NAME, val)?;
-66
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &UNTAGLOGGROUPINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-73
+                    }
                     Ok(())
                 },
             )?;
-77
+        }
         Ok(())
-79
+    }
-80
+}
 impl UntagLogGroupInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UNTAGLOGGROUPINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UNTAGLOGGROUPINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.log_group_name = Some(deser.read_string(member)?);
-99
+                }
                 Some(1) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.tags = Some(deser.read_string_list(member)?);
-102
+                }
                 _ => {}
-104
+            }
             Ok(())
         })?;
         builder.log_group_name = builder.log_group_name.or(Some(String::new()));
         builder.tags = builder.tags.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-112
+    }
-113
+}
 impl UntagLogGroupInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl UntagLogGroupInput {
     /// Creates a new builder-style object to manufacture [`UntagLogGroupInput`](crate::operation::untag_log_group::UntagLogGroupInput).
     pub fn builder() -> crate::operation::untag_log_group::builders::UntagLogGroupInputBuilder {
         crate::operation::untag_log_group::builders::UntagLogGroupInputBuilder::default()
-129
+    }
-130
+}
-131
 /// A builder for [`UntagLogGroupInput`](crate::operation::untag_log_group::UntagLogGroupInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UntagLogGroupInputBuilder {
     pub(crate) log_group_name: ::std::option::Option<::std::string::String>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-138
+}
 impl UntagLogGroupInputBuilder {
     /// <p>The name of the log group.</p>
     /// This field is required.
     pub fn log_group_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.log_group_name = ::std::option::Option::Some(input.into());
         self
-145
+    }
     /// <p>The name of the log group.</p>
     pub fn set_log_group_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.log_group_name = input;
         self
-150
+    }
     /// <p>The name of the log group.</p>
     pub fn get_log_group_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.log_group_name
-154
+    }

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/untag_log_group/_untag_log_group_output.rs

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UntagLogGroupOutput {
     _request_id: Option<String>,
-7
+}
 static UNTAGLOGGROUPOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#UntagLogGroupOutput",
     "com.amazonaws.cloudwatchlogs.synthetic",
     "UntagLogGroupOutput",
 );
 static UNTAGLOGGROUPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(UNTAGLOGGROUPOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static UNTAGLOGGROUPOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UNTAGLOGGROUPOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UNTAGLOGGROUPOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UNTAGLOGGROUPOUTPUT_MEMBER__REQUEST_ID],
 );
 impl UntagLogGroupOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UNTAGLOGGROUPOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UntagLogGroupOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-36
+    }
-37
+}
 impl UntagLogGroupOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UNTAGLOGGROUPOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UNTAGLOGGROUPOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl UntagLogGroupOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for UntagLogGroupOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl UntagLogGroupOutput {
     /// Creates a new builder-style object to manufacture [`UntagLogGroupOutput`](crate::operation::untag_log_group::UntagLogGroupOutput).
     pub fn builder() -> crate::operation::untag_log_group::builders::UntagLogGroupOutputBuilder {
         crate::operation::untag_log_group::builders::UntagLogGroupOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`UntagLogGroupOutput`](crate::operation::untag_log_group::UntagLogGroupOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UntagLogGroupOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl UntagLogGroupOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`UntagLogGroupOutput`](crate::operation::untag_log_group::UntagLogGroupOutput).
     pub fn build(self) -> crate::operation::untag_log_group::UntagLogGroupOutput {

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/untag_resource.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `UntagResource`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UntagResource;
 impl UntagResource {
     /// Creates a new `UntagResource`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::untag_resource::UntagResourceInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::untag_resource::UntagResourceOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::untag_resource::UntagResourceInput,
     ) -> ::std::result::Result<
         crate::operation::untag_resource::UntagResourceOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::untag_resource::UntagResourceError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::untag_resource::UntagResourceError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::untag_resource::UntagResourceOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +245,330 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UntagResource")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UntagResourceEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::untag_resource::UntagResourceError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::untag_resource::UntagResourceError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::untag_resource::UntagResourceError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UntagResourceResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UntagResourceResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_untag_resource::de_untag_resource_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::untag_resource::UntagResourceError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InvalidParameterException" => crate::operation::untag_resource::UntagResourceError::InvalidParameterException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidParameterException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidParameterException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::untag_resource::UntagResourceError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::untag_resource::UntagResourceError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::untag_resource::UntagResourceError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_untag_resource::de_untag_resource_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, UntagResource::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::untag_resource::UntagResourceOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-279
+    }
-280
+}
 #[derive(Debug)]
 struct UntagResourceRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UntagResourceRequestSerializer {
     #[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::untag_resource::UntagResourceInput>()
             .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::untag_resource::UntagResourceInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::untag_resource::UntagResourceInput,
                 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))
--
+            }
             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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "Logs_20140328.UntagResource",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_untag_resource::ser_untag_resource_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_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, UntagResource::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-301
+    }
-302
+}
 #[derive(Debug)]
 struct UntagResourceEndpointParamsInterceptor;
-305
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UntagResourceEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UntagResourceEndpointParamsInterceptor"
-309
+    }
-310

↧ Expand context

     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::<UntagResourceInput>()
             .ok_or("failed to downcast to UntagResourceInput")?;
-325
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/untag_resource/_untag_resource_input.rs

@@ -11,11 +156,159 @@

↥ Expand context

     /// <p>The list of tag keys to remove from the resource.</p>
     pub tag_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-13
+}
 impl UntagResourceInput {
     /// <p>The ARN of the CloudWatch Logs resource that you're removing tags from.</p>
     /// <p>The ARN format of a log group is <code>arn:aws:logs:<i>Region</i>:<i>account-id</i>:log-group:<i>log-group-name</i> </code></p>
     /// <p>The ARN format of a destination is <code>arn:aws:logs:<i>Region</i>:<i>account-id</i>:destination:<i>destination-name</i> </code></p>
     /// <p>For more information about ARN format, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html">CloudWatch Logs resources and operations</a>.</p>
     pub fn resource_arn(&self) -> ::std::option::Option<&str> {
         self.resource_arn.as_deref()
-21
+    }
     /// <p>The list of tag keys to remove from the resource.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tag_keys.is_none()`.
     pub fn tag_keys(&self) -> &[::std::string::String] {
         self.tag_keys.as_deref().unwrap_or_default()
-27
+    }
-28
+}
 static UNTAGRESOURCEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#UntagResourceInput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "UntagResourceInput",
 );
 static UNTAGRESOURCEINPUT_MEMBER_RESOURCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UntagResourceInput$resourceArn",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UntagResourceInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_arn",
     "resourceArn",
 ,
 );
 static UNTAGRESOURCEINPUT_MEMBER_TAG_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UntagResourceInput$tagKeys",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UntagResourceInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tag_keys",
     "tagKeys",
 ,
 );
 static UNTAGRESOURCEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UNTAGRESOURCEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UNTAGRESOURCEINPUT_MEMBER_RESOURCE_ARN, &UNTAGRESOURCEINPUT_MEMBER_TAG_KEYS],
 );
 impl UntagResourceInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UNTAGRESOURCEINPUT_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UntagResourceInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.resource_arn {
             ser.write_string(&UNTAGRESOURCEINPUT_MEMBER_RESOURCE_ARN, val)?;
-71
+        }
         if let Some(ref val) = self.tag_keys {
             ser.write_list(
                 &UNTAGRESOURCEINPUT_MEMBER_TAG_KEYS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-78
+                    }
                     Ok(())
                 },
             )?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl UntagResourceInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UNTAGRESOURCEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UNTAGRESOURCEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.resource_arn = Some(deser.read_string(member)?);
-104
+                }
                 Some(1) => {
                     builder.tag_keys = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.tag_keys = Some(deser.read_string_list(member)?);
-107
+                }
                 _ => {}
-109
+            }
             Ok(())
         })?;
         builder.resource_arn = builder.resource_arn.or(Some(String::new()));
         builder.tag_keys = builder.tag_keys.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-117
+    }
-118
+}
 impl UntagResourceInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl UntagResourceInput {
     /// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::operation::untag_resource::UntagResourceInput).
     pub fn builder() -> crate::operation::untag_resource::builders::UntagResourceInputBuilder {
         crate::operation::untag_resource::builders::UntagResourceInputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`UntagResourceInput`](crate::operation::untag_resource::UntagResourceInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UntagResourceInputBuilder {
     pub(crate) resource_arn: ::std::option::Option<::std::string::String>,
     pub(crate) tag_keys: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
-143
+}
 impl UntagResourceInputBuilder {
     /// <p>The ARN of the CloudWatch Logs resource that you're removing tags from.</p>
     /// <p>The ARN format of a log group is <code>arn:aws:logs:<i>Region</i>:<i>account-id</i>:log-group:<i>log-group-name</i> </code></p>
     /// <p>The ARN format of a destination is <code>arn:aws:logs:<i>Region</i>:<i>account-id</i>:destination:<i>destination-name</i> </code></p>
     /// <p>For more information about ARN format, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html">CloudWatch Logs resources and operations</a>.</p>
     /// This field is required.
     pub fn resource_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.resource_arn = ::std::option::Option::Some(input.into());
         self
-153
+    }
     /// <p>The ARN of the CloudWatch Logs resource that you're removing tags from.</p>
     /// <p>The ARN format of a log group is <code>arn:aws:logs:<i>Region</i>:<i>account-id</i>:log-group:<i>log-group-name</i> </code></p>
     /// <p>The ARN format of a destination is <code>arn:aws:logs:<i>Region</i>:<i>account-id</i>:destination:<i>destination-name</i> </code></p>
     /// <p>For more information about ARN format, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html">CloudWatch Logs resources and operations</a>.</p>
     pub fn set_resource_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.resource_arn = input;

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/untag_resource/_untag_resource_output.rs

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UntagResourceOutput {
     _request_id: Option<String>,
-7
+}
 static UNTAGRESOURCEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#UntagResourceOutput",
     "com.amazonaws.cloudwatchlogs.synthetic",
     "UntagResourceOutput",
 );
 static UNTAGRESOURCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(UNTAGRESOURCEOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static UNTAGRESOURCEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UNTAGRESOURCEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UNTAGRESOURCEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UNTAGRESOURCEOUTPUT_MEMBER__REQUEST_ID],
 );
 impl UntagResourceOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UNTAGRESOURCEOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UntagResourceOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-36
+    }
-37
+}
 impl UntagResourceOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UNTAGRESOURCEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UNTAGRESOURCEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl UntagResourceOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for UntagResourceOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl UntagResourceOutput {
     /// Creates a new builder-style object to manufacture [`UntagResourceOutput`](crate::operation::untag_resource::UntagResourceOutput).
     pub fn builder() -> crate::operation::untag_resource::builders::UntagResourceOutputBuilder {
         crate::operation::untag_resource::builders::UntagResourceOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`UntagResourceOutput`](crate::operation::untag_resource::UntagResourceOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UntagResourceOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl UntagResourceOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`UntagResourceOutput`](crate::operation::untag_resource::UntagResourceOutput).
     pub fn build(self) -> crate::operation::untag_resource::UntagResourceOutput {

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/update_anomaly.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `UpdateAnomaly`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateAnomaly;
 impl UpdateAnomaly {
     /// Creates a new `UpdateAnomaly`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::update_anomaly::UpdateAnomalyInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::update_anomaly::UpdateAnomalyOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::update_anomaly::UpdateAnomalyInput,
     ) -> ::std::result::Result<
         crate::operation::update_anomaly::UpdateAnomalyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::update_anomaly::UpdateAnomalyError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::update_anomaly::UpdateAnomalyError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::update_anomaly::UpdateAnomalyOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +245,354 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UpdateAnomaly")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateAnomalyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_anomaly::UpdateAnomalyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_anomaly::UpdateAnomalyError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_anomaly::UpdateAnomalyError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UpdateAnomalyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateAnomalyResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_update_anomaly::de_update_anomaly_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::update_anomaly::UpdateAnomalyError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InvalidParameterException" => crate::operation::update_anomaly::UpdateAnomalyError::InvalidParameterException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidParameterException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidParameterException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "OperationAbortedException" => crate::operation::update_anomaly::UpdateAnomalyError::OperationAbortedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::OperationAbortedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::OperationAbortedException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::update_anomaly::UpdateAnomalyError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::update_anomaly::UpdateAnomalyError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::update_anomaly::UpdateAnomalyError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_update_anomaly::de_update_anomaly_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, UpdateAnomaly::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::update_anomaly::UpdateAnomalyOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-303
+    }
-304
+}
 #[derive(Debug)]
 struct UpdateAnomalyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateAnomalyRequestSerializer {
     #[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::update_anomaly::UpdateAnomalyInput>()
             .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::update_anomaly::UpdateAnomalyInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_anomaly::UpdateAnomalyInput,
                 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))
--
+            }
             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/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "Logs_20140328.UpdateAnomaly",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_anomaly::ser_update_anomaly_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_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, UpdateAnomaly::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-325
+    }
-326
+}
 #[derive(Debug)]
 struct UpdateAnomalyEndpointParamsInterceptor;
-329
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateAnomalyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateAnomalyEndpointParamsInterceptor"
-333
+    }
-334

↧ Expand context

     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::<UpdateAnomalyInput>()
             .ok_or("failed to downcast to UpdateAnomalyInput")?;
-349
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/update_anomaly/_update_anomaly_input.rs

@@ -29,29 +227,239 @@

↥ Expand context

     /// <p>The ARN of the anomaly detector that this operation is to act on.</p>
     pub fn anomaly_detector_arn(&self) -> ::std::option::Option<&str> {
         self.anomaly_detector_arn.as_deref()
-32
+    }
     /// <p>Use this to specify whether the suppression to be temporary or infinite. If you specify <code>LIMITED</code>, you must also specify a <code>suppressionPeriod</code>. If you specify <code>INFINITE</code>, any value for <code>suppressionPeriod</code> is ignored.</p>
     pub fn suppression_type(&self) -> ::std::option::Option<&crate::types::SuppressionType> {
         self.suppression_type.as_ref()
-36
+    }
     /// <p>If you are temporarily suppressing an anomaly or pattern, use this structure to specify how long the suppression is to last.</p>
     pub fn suppression_period(&self) -> ::std::option::Option<&crate::types::SuppressionPeriod> {
         self.suppression_period.as_ref()
-40
+    }
     /// <p>Set this to <code>true</code> to prevent CloudWatch Logs from displaying this behavior as an anomaly in the future. The behavior is then treated as baseline behavior. However, if similar but more severe occurrences of this behavior occur in the future, those will still be reported as anomalies.</p>
     /// <p>The default is <code>false</code></p>
     pub fn baseline(&self) -> ::std::option::Option<bool> {
         self.baseline
-45
+    }
-46
+}
 static UPDATEANOMALYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyInput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "UpdateAnomalyInput",
 );
 static UPDATEANOMALYINPUT_MEMBER_ANOMALY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyInput$anomalyId",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UpdateAnomalyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "anomaly_id",
     "anomalyId",
 ,
 );
 static UPDATEANOMALYINPUT_MEMBER_PATTERN_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyInput$patternId",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UpdateAnomalyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "pattern_id",
     "patternId",
 ,
 );
 static UPDATEANOMALYINPUT_MEMBER_ANOMALY_DETECTOR_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyInput$anomalyDetectorArn",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UpdateAnomalyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "anomaly_detector_arn",
     "anomalyDetectorArn",
 ,
 );
 static UPDATEANOMALYINPUT_MEMBER_SUPPRESSION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyInput$suppressionType",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UpdateAnomalyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "suppression_type",
     "suppressionType",
 ,
 );
 static UPDATEANOMALYINPUT_MEMBER_SUPPRESSION_PERIOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyInput$suppressionPeriod",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UpdateAnomalyInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "suppression_period",
     "suppressionPeriod",
 ,
 );
 static UPDATEANOMALYINPUT_MEMBER_BASELINE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyInput$baseline",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "UpdateAnomalyInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "baseline",
 ,
 );
 static UPDATEANOMALYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATEANOMALYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPDATEANOMALYINPUT_MEMBER_ANOMALY_ID,
         &UPDATEANOMALYINPUT_MEMBER_PATTERN_ID,
         &UPDATEANOMALYINPUT_MEMBER_ANOMALY_DETECTOR_ARN,
         &UPDATEANOMALYINPUT_MEMBER_SUPPRESSION_TYPE,
         &UPDATEANOMALYINPUT_MEMBER_SUPPRESSION_PERIOD,
         &UPDATEANOMALYINPUT_MEMBER_BASELINE,
     ],
 );
 impl UpdateAnomalyInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATEANOMALYINPUT_SCHEMA;
-127
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateAnomalyInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.anomaly_id {
             ser.write_string(&UPDATEANOMALYINPUT_MEMBER_ANOMALY_ID, val)?;
-136
+        }
         if let Some(ref val) = self.pattern_id {
             ser.write_string(&UPDATEANOMALYINPUT_MEMBER_PATTERN_ID, val)?;
-139
+        }
         if let Some(ref val) = self.anomaly_detector_arn {
             ser.write_string(&UPDATEANOMALYINPUT_MEMBER_ANOMALY_DETECTOR_ARN, val)?;
-142
+        }
         if let Some(ref val) = self.suppression_type {
             ser.write_string(&UPDATEANOMALYINPUT_MEMBER_SUPPRESSION_TYPE, val.as_str())?;
-145
+        }
         if let Some(ref val) = self.suppression_period {
             ser.write_struct(&UPDATEANOMALYINPUT_MEMBER_SUPPRESSION_PERIOD, val)?;
-148
+        }
         if let Some(ref val) = self.baseline {
             ser.write_boolean(&UPDATEANOMALYINPUT_MEMBER_BASELINE, *val)?;
-151
+        }
         Ok(())
-153
+    }
-154
+}
 impl UpdateAnomalyInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPDATEANOMALYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATEANOMALYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.anomaly_id = Some(deser.read_string(member)?);
-173
+                }
                 Some(1) => {
                     builder.pattern_id = Some(deser.read_string(member)?);
-176
+                }
                 Some(2) => {
                     builder.anomaly_detector_arn = Some(deser.read_string(member)?);
-179
+                }
                 Some(3) => {
                     builder.suppression_type = Some(crate::types::SuppressionType::from(deser.read_string(member)?.as_str()));
-182
+                }
                 Some(4) => {
                     builder.suppression_period = Some(crate::types::SuppressionPeriod::deserialize(deser)?);
-185
+                }
                 Some(5) => {
                     builder.baseline = Some(deser.read_boolean(member)?);
-188
+                }
                 _ => {}
-190
+            }
             Ok(())
         })?;
         builder.anomaly_detector_arn = builder.anomaly_detector_arn.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-197
+    }
-198
+}
 impl UpdateAnomalyInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl UpdateAnomalyInput {
     /// Creates a new builder-style object to manufacture [`UpdateAnomalyInput`](crate::operation::update_anomaly::UpdateAnomalyInput).
     pub fn builder() -> crate::operation::update_anomaly::builders::UpdateAnomalyInputBuilder {
         crate::operation::update_anomaly::builders::UpdateAnomalyInputBuilder::default()
-214
+    }
-215
+}
-216
 /// A builder for [`UpdateAnomalyInput`](crate::operation::update_anomaly::UpdateAnomalyInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateAnomalyInputBuilder {
     pub(crate) anomaly_id: ::std::option::Option<::std::string::String>,
     pub(crate) pattern_id: ::std::option::Option<::std::string::String>,
     pub(crate) anomaly_detector_arn: ::std::option::Option<::std::string::String>,
     pub(crate) suppression_type: ::std::option::Option<crate::types::SuppressionType>,
     pub(crate) suppression_period: ::std::option::Option<crate::types::SuppressionPeriod>,
     pub(crate) baseline: ::std::option::Option<bool>,
-227
+}
 impl UpdateAnomalyInputBuilder {
     /// <p>If you are suppressing or unsuppressing an anomaly, specify its unique ID here. You can find anomaly IDs by using the <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListAnomalies.html">ListAnomalies</a> operation.</p>
     pub fn anomaly_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.anomaly_id = ::std::option::Option::Some(input.into());
         self
-233
+    }
     /// <p>If you are suppressing or unsuppressing an anomaly, specify its unique ID here. You can find anomaly IDs by using the <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListAnomalies.html">ListAnomalies</a> operation.</p>
     pub fn set_anomaly_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.anomaly_id = input;
         self
-238
+    }
     /// <p>If you are suppressing or unsuppressing an anomaly, specify its unique ID here. You can find anomaly IDs by using the <a href="https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_ListAnomalies.html">ListAnomalies</a> operation.</p>

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/update_anomaly/_update_anomaly_output.rs

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateAnomalyOutput {
     _request_id: Option<String>,
-7
+}
 static UPDATEANOMALYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#UpdateAnomalyOutput",
     "com.amazonaws.cloudwatchlogs.synthetic",
     "UpdateAnomalyOutput",
 );
 static UPDATEANOMALYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(UPDATEANOMALYOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static UPDATEANOMALYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UPDATEANOMALYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATEANOMALYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATEANOMALYOUTPUT_MEMBER__REQUEST_ID],
 );
 impl UpdateAnomalyOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATEANOMALYOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateAnomalyOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-36
+    }
-37
+}
 impl UpdateAnomalyOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPDATEANOMALYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATEANOMALYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl UpdateAnomalyOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for UpdateAnomalyOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl UpdateAnomalyOutput {
     /// Creates a new builder-style object to manufacture [`UpdateAnomalyOutput`](crate::operation::update_anomaly::UpdateAnomalyOutput).
     pub fn builder() -> crate::operation::update_anomaly::builders::UpdateAnomalyOutputBuilder {
         crate::operation::update_anomaly::builders::UpdateAnomalyOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`UpdateAnomalyOutput`](crate::operation::update_anomaly::UpdateAnomalyOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateAnomalyOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl UpdateAnomalyOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`UpdateAnomalyOutput`](crate::operation::update_anomaly::UpdateAnomalyOutput).
     pub fn build(self) -> crate::operation::update_anomaly::UpdateAnomalyOutput {

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`

AWS SDK

Files changed: