AWS SDK

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/put_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 `PutTransformer`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutTransformer;
 impl PutTransformer {
     /// Creates a new `PutTransformer`
     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::put_transformer::PutTransformerInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::put_transformer::PutTransformerOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::put_transformer::PutTransformerInput,
     ) -> ::std::result::Result<
         crate::operation::put_transformer::PutTransformerOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::put_transformer::PutTransformerError,
             ::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::put_transformer::PutTransformerError>()
                     .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::put_transformer::PutTransformerOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +245,406 @@

↥ 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("PutTransformer")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutTransformerEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_transformer::PutTransformerError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_transformer::PutTransformerError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::put_transformer::PutTransformerError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct PutTransformerResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutTransformerResponseDeserializer {
     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_put_transformer::de_put_transformer_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_transformer::de_put_transformer_http_response(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::put_transformer::PutTransformerError::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::put_transformer::PutTransformerError::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::put_transformer::PutTransformerError::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
                 }),
                 "LimitExceededException" => crate::operation::put_transformer::PutTransformerError::LimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededException::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),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "OperationAbortedException" => crate::operation::put_transformer::PutTransformerError::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::put_transformer::PutTransformerError::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::put_transformer::PutTransformerError::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::put_transformer::PutTransformerError::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 {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, PutTransformer::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::put_transformer::PutTransformerOutput::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))
-+
+        }
-355
+    }
-356
+}
 #[derive(Debug)]
 struct PutTransformerRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutTransformerRequestSerializer {
     #[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::put_transformer::PutTransformerInput>()
             .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::put_transformer::PutTransformerInput,
                 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::put_transformer::PutTransformerInput,
                 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.PutTransformer",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_transformer::ser_put_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, PutTransformer::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-377
+    }
-378
+}
 #[derive(Debug)]
 struct PutTransformerEndpointParamsInterceptor;
-381
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutTransformerEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutTransformerEndpointParamsInterceptor"
-385
+    }
-386

↧ 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::<PutTransformerInput>()
             .ok_or("failed to downcast to PutTransformerInput")?;
-401
         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/put_transformer/_put_transformer_input.rs

@@ -5,5 +153,163 @@

↥ Expand context

 pub struct PutTransformerInput {
     /// <p>Specify either the name or ARN of the log group to create the transformer for.</p>
     pub log_group_identifier: ::std::option::Option<::std::string::String>,
     /// <p>This structure contains the configuration of this log transformer. 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 transformer_config: ::std::option::Option<::std::vec::Vec<crate::types::Processor>>,
-10
+}
 impl PutTransformerInput {
     /// <p>Specify either the name or ARN of the log group to create the transformer for.</p>
     pub fn log_group_identifier(&self) -> ::std::option::Option<&str> {
         self.log_group_identifier.as_deref()
-15
+    }
     /// <p>This structure contains the configuration of this log transformer. 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()
-21
+    }
-22
+}
 static PUTTRANSFORMERINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#PutTransformerInput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "PutTransformerInput",
 );
 static PUTTRANSFORMERINPUT_MEMBER_LOG_GROUP_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#PutTransformerInput$logGroupIdentifier",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "PutTransformerInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "log_group_identifier",
     "logGroupIdentifier",
 ,
 );
 static PUTTRANSFORMERINPUT_MEMBER_TRANSFORMER_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#PutTransformerInput$transformerConfig",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "PutTransformerInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "transformer_config",
     "transformerConfig",
 ,
 );
 static PUTTRANSFORMERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTTRANSFORMERINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTTRANSFORMERINPUT_MEMBER_LOG_GROUP_IDENTIFIER,
         &PUTTRANSFORMERINPUT_MEMBER_TRANSFORMER_CONFIG,
     ],
 );
 impl PutTransformerInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTTRANSFORMERINPUT_SCHEMA;
-59
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutTransformerInput {
     #[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_identifier {
             ser.write_string(&PUTTRANSFORMERINPUT_MEMBER_LOG_GROUP_IDENTIFIER, val)?;
-68
+        }
         if let Some(ref val) = self.transformer_config {
             ser.write_list(
                 &PUTTRANSFORMERINPUT_MEMBER_TRANSFORMER_CONFIG,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Processor::SCHEMA, item)?;
-75
+                    }
                     Ok(())
                 },
             )?;
-79
+        }
         Ok(())
-81
+    }
-82
+}
 impl PutTransformerInput {
     /// 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(&PUTTRANSFORMERINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTTRANSFORMERINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.log_group_identifier = Some(deser.read_string(member)?);
-101
+                }
                 Some(1) => {
                     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
                     });
-111
+                }
                 _ => {}
-113
+            }
             Ok(())
         })?;
         builder.log_group_identifier = builder.log_group_identifier.or(Some(String::new()));
         builder.transformer_config = builder.transformer_config.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-121
+    }
-122
+}
 impl PutTransformerInput {
     /// 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 PutTransformerInput {
     /// Creates a new builder-style object to manufacture [`PutTransformerInput`](crate::operation::put_transformer::PutTransformerInput).
     pub fn builder() -> crate::operation::put_transformer::builders::PutTransformerInputBuilder {
         crate::operation::put_transformer::builders::PutTransformerInputBuilder::default()
-138
+    }
-139
+}
-140
 /// A builder for [`PutTransformerInput`](crate::operation::put_transformer::PutTransformerInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutTransformerInputBuilder {
     pub(crate) log_group_identifier: ::std::option::Option<::std::string::String>,
     pub(crate) transformer_config: ::std::option::Option<::std::vec::Vec<crate::types::Processor>>,
-147
+}
 impl PutTransformerInputBuilder {
     /// <p>Specify either the name or ARN of the log group to create the transformer for.</p>
     /// This field is required.
     pub fn log_group_identifier(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.log_group_identifier = ::std::option::Option::Some(input.into());
         self
-154
+    }
     /// <p>Specify either the name or ARN of the log group to create the transformer for.</p>
     pub fn set_log_group_identifier(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.log_group_identifier = input;
         self
-159
+    }
     /// <p>Specify either the name or ARN of the log group to create the transformer for.</p>
     pub fn get_log_group_identifier(&self) -> &::std::option::Option<::std::string::String> {
         &self.log_group_identifier
-163
+    }

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

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

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutTransformerOutput {
     _request_id: Option<String>,
-7
+}
 static PUTTRANSFORMEROUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#PutTransformerOutput",
     "com.amazonaws.cloudwatchlogs.synthetic",
     "PutTransformerOutput",
 );
 static PUTTRANSFORMEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(PUTTRANSFORMEROUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static PUTTRANSFORMEROUTPUT_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 PUTTRANSFORMEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTTRANSFORMEROUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTTRANSFORMEROUTPUT_MEMBER__REQUEST_ID],
 );
 impl PutTransformerOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTTRANSFORMEROUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutTransformerOutput {
     #[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 PutTransformerOutput {
     /// 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(&PUTTRANSFORMEROUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTTRANSFORMEROUTPUT_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 PutTransformerOutput {
     /// 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 PutTransformerOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl PutTransformerOutput {
     /// Creates a new builder-style object to manufacture [`PutTransformerOutput`](crate::operation::put_transformer::PutTransformerOutput).
     pub fn builder() -> crate::operation::put_transformer::builders::PutTransformerOutputBuilder {
         crate::operation::put_transformer::builders::PutTransformerOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`PutTransformerOutput`](crate::operation::put_transformer::PutTransformerOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutTransformerOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl PutTransformerOutputBuilder {
     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 [`PutTransformerOutput`](crate::operation::put_transformer::PutTransformerOutput).
     pub fn build(self) -> crate::operation::put_transformer::PutTransformerOutput {

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StartLiveTail`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartLiveTail;
 impl StartLiveTail {
     /// Creates a new `StartLiveTail`
     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::start_live_tail::StartLiveTailInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::start_live_tail::StartLiveTailOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_live_tail::StartLiveTailInput,
     ) -> ::std::result::Result<
         crate::operation::start_live_tail::StartLiveTailOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_live_tail::StartLiveTailError,
             ::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::start_live_tail::StartLiveTailError>()
                     .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::start_live_tail::StartLiveTailOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -134,138 +256,420 @@

↥ Expand context

                 crate::operation::start_live_tail::StartLiveTailError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::start_live_tail::StartLiveTailError,
             >::new());
-143
         ::std::borrow::Cow::Owned(rcb)
-145
+    }
-146
+}
-147
 #[derive(Debug)]
 struct StartLiveTailResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartLiveTailResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));

-158
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-162
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_start_live_tail::de_start_live_tail_http_response(response),
         ))
-166
+    }
-167
     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 {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_start_live_tail::de_start_live_tail_http_error(
             response.status().as_u16(),
         let status = response.status().as_u16();
         let headers = response.headers();
         #[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::start_live_tail::StartLiveTailError::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 {
             "AccessDeniedException" => crate::operation::start_live_tail::StartLiveTailError::AccessDeniedException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::AccessDeniedException::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
             }),
             "InvalidOperationException" => crate::operation::start_live_tail::StartLiveTailError::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::start_live_tail::StartLiveTailError::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
             }),
             "LimitExceededException" => crate::operation::start_live_tail::StartLiveTailError::LimitExceededException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::LimitExceededException::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::start_live_tail::StartLiveTailError::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
             }),
             "SessionTimeoutException" => crate::operation::start_live_tail::StartLiveTailError::SessionTimeoutException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::SessionTimeoutException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::SessionTimeoutException::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
             }),
             "SessionStreamingException" => crate::operation::start_live_tail::StartLiveTailError::SessionStreamingException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::SessionStreamingException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::SessionStreamingException::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::start_live_tail::StartLiveTailError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-369
+    }
-370
+}
 #[derive(Debug)]
 struct StartLiveTailRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartLiveTailRequestSerializer {
     #[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::start_live_tail::StartLiveTailInput>()
             .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::start_live_tail::StartLiveTailInput,
                 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::start_live_tail::StartLiveTailInput,
                 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.StartLiveTail",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_start_live_tail::ser_start_live_tail_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, StartLiveTail::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-391
+    }
-392
+}
 #[derive(Debug)]
 struct StartLiveTailEndpointParamsInterceptor;
-395
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartLiveTailEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartLiveTailEndpointParamsInterceptor"
-399
+    }
-400

↧ 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::<StartLiveTailInput>()
             .ok_or("failed to downcast to StartLiveTailInput")?;
-415
         let endpoint_prefix = ::aws_smithy_runtime_api::client::endpoint::EndpointPrefix::new("streaming-").map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint prefix could not be built", err)
         })?;
         cfg.interceptor_state().store_put(endpoint_prefix);
-420

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

@@ -45,45 +135,135 @@

↥ Expand context

         self.log_stream_names.as_deref().unwrap_or_default()
-46
+    }
     /// <p>If you specify this parameter, then only log events in the log streams that have names that start with the prefixes that you specify here are included in the Live Tail session.</p>
     /// <p>If you specify this field, you can't also specify the <code>logStreamNames</code> field.</p><note>
     /// <p>You can specify this parameter only if you specify only one log group in <code>logGroupIdentifiers</code>.</p>
     /// </note>
     ///
     /// 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_stream_name_prefixes.is_none()`.
     pub fn log_stream_name_prefixes(&self) -> &[::std::string::String] {
         self.log_stream_name_prefixes.as_deref().unwrap_or_default()
-55
+    }
     /// <p>An optional pattern to use to filter the results to include only log events that match the pattern. For example, a filter pattern of <code>error 404</code> causes only log events that include both <code>error</code> and <code>404</code> to be included in the Live Tail stream.</p>
     /// <p>Regular expression filter patterns are supported.</p>
     /// <p>For more information about filter pattern syntax, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html">Filter and Pattern Syntax</a>.</p>
     pub fn log_event_filter_pattern(&self) -> ::std::option::Option<&str> {
         self.log_event_filter_pattern.as_deref()
-61
+    }
-62
+}
 static STARTLIVETAILINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#StartLiveTailInput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "StartLiveTailInput",
 );
 static STARTLIVETAILINPUT_MEMBER_LOG_GROUP_IDENTIFIERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartLiveTailInput$logGroupIdentifiers",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartLiveTailInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "log_group_identifiers",
     "logGroupIdentifiers",
 ,
 );
 static STARTLIVETAILINPUT_MEMBER_LOG_STREAM_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartLiveTailInput$logStreamNames",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartLiveTailInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "log_stream_names",
     "logStreamNames",
 ,
 );
 static STARTLIVETAILINPUT_MEMBER_LOG_STREAM_NAME_PREFIXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartLiveTailInput$logStreamNamePrefixes",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartLiveTailInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "log_stream_name_prefixes",
     "logStreamNamePrefixes",
 ,
 );
 static STARTLIVETAILINPUT_MEMBER_LOG_EVENT_FILTER_PATTERN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartLiveTailInput$logEventFilterPattern",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartLiveTailInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "log_event_filter_pattern",
     "logEventFilterPattern",
 ,
 );
 static STARTLIVETAILINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTLIVETAILINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTLIVETAILINPUT_MEMBER_LOG_GROUP_IDENTIFIERS,
         &STARTLIVETAILINPUT_MEMBER_LOG_STREAM_NAMES,
         &STARTLIVETAILINPUT_MEMBER_LOG_STREAM_NAME_PREFIXES,
         &STARTLIVETAILINPUT_MEMBER_LOG_EVENT_FILTER_PATTERN,

↧ Expand context

     ],
 );
 impl StartLiveTailInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTLIVETAILINPUT_SCHEMA;
-121
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartLiveTailInput {
     #[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_identifiers {
             ser.write_list(
                 &STARTLIVETAILINPUT_MEMBER_LOG_GROUP_IDENTIFIERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-134
+                    }
                     Ok(())

@@ -139,139 +263,245 @@

↥ Expand context

         if let Some(ref val) = self.log_stream_names {
             ser.write_list(
                 &STARTLIVETAILINPUT_MEMBER_LOG_STREAM_NAMES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-145
+                    }
                     Ok(())
                 },
             )?;
-149
+        }
         if let Some(ref val) = self.log_stream_name_prefixes {
             ser.write_list(
                 &STARTLIVETAILINPUT_MEMBER_LOG_STREAM_NAME_PREFIXES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-156
+                    }
                     Ok(())
                 },

             )?;
-160
+        }
         if let Some(ref val) = self.log_event_filter_pattern {
             ser.write_string(&STARTLIVETAILINPUT_MEMBER_LOG_EVENT_FILTER_PATTERN, val)?;
-163
+        }
         Ok(())
-165
+    }
-166
+}
 impl StartLiveTailInput {
     /// 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(&STARTLIVETAILINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTLIVETAILINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.log_group_identifiers = 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_group_identifiers = Some(deser.read_string_list(member)?);
-185
+                }
                 Some(1) => {
                     builder.log_stream_names = 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_stream_names = Some(deser.read_string_list(member)?);
-188
+                }
                 Some(2) => {
                     builder.log_stream_name_prefixes = 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_stream_name_prefixes = Some(deser.read_string_list(member)?);
-191
+                }
                 Some(3) => {
                     builder.log_event_filter_pattern = Some(deser.read_string(member)?);
-194
+                }
                 _ => {}
-196
+            }
             Ok(())
         })?;
         builder.log_group_identifiers = builder.log_group_identifiers.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-203
+    }
-204
+}
 impl StartLiveTailInput {
     /// 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 StartLiveTailInput {
     /// Creates a new builder-style object to manufacture [`StartLiveTailInput`](crate::operation::start_live_tail::StartLiveTailInput).
     pub fn builder() -> crate::operation::start_live_tail::builders::StartLiveTailInputBuilder {
         crate::operation::start_live_tail::builders::StartLiveTailInputBuilder::default()
-220
+    }
-221
+}
-222
 /// A builder for [`StartLiveTailInput`](crate::operation::start_live_tail::StartLiveTailInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StartLiveTailInputBuilder {
     pub(crate) log_group_identifiers: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) log_stream_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) log_stream_name_prefixes: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) log_event_filter_pattern: ::std::option::Option<::std::string::String>,
-231
+}
 impl StartLiveTailInputBuilder {
     /// Appends an item to `log_group_identifiers`.
     ///
     /// To override the contents of this collection use [`set_log_group_identifiers`](Self::set_log_group_identifiers).
     ///
     /// <p>An array where each item in the array is a log group to include in the Live Tail session.</p>
     /// <p>Specify each log group by its ARN.</p>
     /// <p>If you specify an ARN, the ARN can't end with an asterisk (*).</p><note>
     /// <p>You can include up to 10 log groups.</p>
     /// </note>
     pub fn log_group_identifiers(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         let mut v = self.log_group_identifiers.unwrap_or_default();
         v.push(input.into());
         self.log_group_identifiers = ::std::option::Option::Some(v);

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

@@ -1,1 +105,150 @@

↥ 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::fmt::Debug)]
 pub struct StartLiveTailOutput {
     /// <p>An object that includes the stream returned by your request. It can include both log events and exceptions.</p>
     pub response_stream:
         crate::event_receiver::EventReceiver<crate::types::StartLiveTailResponseStream, crate::types::error::StartLiveTailResponseStreamError>,
     _request_id: Option<String>,
-10
+}
 impl StartLiveTailOutput {
     /// <p>An object that includes the stream returned by your request. It can include both log events and exceptions.</p>
     pub fn response_stream(
         &self,
     ) -> &crate::event_receiver::EventReceiver<crate::types::StartLiveTailResponseStream, crate::types::error::StartLiveTailResponseStreamError> {
         &self.response_stream
-17
+    }
-18
+}
 static STARTLIVETAILOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#StartLiveTailOutput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "StartLiveTailOutput",
 );
 static STARTLIVETAILOUTPUT_MEMBER_RESPONSE_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartLiveTailOutput$responseStream",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartLiveTailOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "response_stream",
     "responseStream",
 ,
 );
 static STARTLIVETAILOUTPUT_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 STARTLIVETAILOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTLIVETAILOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STARTLIVETAILOUTPUT_MEMBER_RESPONSE_STREAM],
     &[&STARTLIVETAILOUTPUT_MEMBER_RESPONSE_STREAM, &STARTLIVETAILOUTPUT_MEMBER__REQUEST_ID],
 );
 impl StartLiveTailOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTLIVETAILOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartLiveTailOutput {
     #[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> {
--
+        {
             let val = &self.response_stream;
             ser.write_null(&STARTLIVETAILOUTPUT_MEMBER_RESPONSE_STREAM)?;
--
+        }
         Ok(())
-57
+    }
-58
+}
 impl StartLiveTailOutput {
     /// 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(&STARTLIVETAILOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.response_stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl StartLiveTailOutput {
     /// 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(&STARTLIVETAILOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTLIVETAILOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.response_stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-122
+                }
                 _ => {}
-124
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-130
+    }

↧ Expand context

-131
+}
 impl ::aws_types::request_id::RequestId for StartLiveTailOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-135
+    }
-136
+}
 impl StartLiveTailOutput {
     /// Creates a new builder-style object to manufacture [`StartLiveTailOutput`](crate::operation::start_live_tail::StartLiveTailOutput).
     pub fn builder() -> crate::operation::start_live_tail::builders::StartLiveTailOutputBuilder {
         crate::operation::start_live_tail::builders::StartLiveTailOutputBuilder::default()
-141
+    }
     #[allow(unused)]
     pub(crate) fn into_builder(self) -> crate::operation::start_live_tail::builders::StartLiveTailOutputBuilder {
         Self::builder().response_stream(self.response_stream)
-145
+    }
-146
+}
-147
 /// A builder for [`StartLiveTailOutput`](crate::operation::start_live_tail::StartLiveTailOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StartQuery`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartQuery;
 impl StartQuery {
     /// Creates a new `StartQuery`
     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::start_query::StartQueryInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::start_query::StartQueryOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_query::StartQueryInput,
     ) -> ::std::result::Result<
         crate::operation::start_query::StartQueryOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_query::StartQueryError,
             ::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::start_query::StartQueryError>()
                     .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::start_query::StartQueryOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +243,376 @@

↥ 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("StartQuery")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(StartQueryEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::start_query::StartQueryError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::start_query::StartQueryError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::start_query::StartQueryError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct StartQueryResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartQueryResponseDeserializer {
     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_start_query::de_start_query_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_start_query::de_start_query_http_response(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::start_query::StartQueryError::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::start_query::StartQueryError::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),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "LimitExceededException" => crate::operation::start_query::StartQueryError::LimitExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::LimitExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::LimitExceededException::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
                 }),
                 "MalformedQueryException" => crate::operation::start_query::StartQueryError::MalformedQueryException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::MalformedQueryException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::MalformedQueryException::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::start_query::StartQueryError::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::start_query::StartQueryError::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::start_query::StartQueryError::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 {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, StartQuery::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::start_query::StartQueryOutput::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))
-+
+        }
-327
+    }
-328
+}
 #[derive(Debug)]
 struct StartQueryRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartQueryRequestSerializer {
     #[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::start_query::StartQueryInput>().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::start_query::StartQueryInput,
                 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::start_query::StartQueryInput,
                 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.StartQuery",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_start_query::ser_start_query_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, StartQuery::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-347
+    }
-348
+}
 #[derive(Debug)]
 struct StartQueryEndpointParamsInterceptor;
-351
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartQueryEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartQueryEndpointParamsInterceptor"
-355
+    }
-356

↧ 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::<StartQueryInput>()
             .ok_or("failed to downcast to StartQueryInput")?;
-371
         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/start_query/_start_query_input.rs

@@ -57,57 +177,177 @@

↥ Expand context

-57
+    }
     /// <p>The beginning of the time range to query. The range is inclusive, so the specified start time is included in the query. Specified as epoch time, the number of seconds since <code>January 1, 1970, 00:00:00 UTC</code>.</p>
     pub fn start_time(&self) -> ::std::option::Option<i64> {
         self.start_time
-61
+    }
     /// <p>The end of the time range to query. The range is inclusive, so the specified end time is included in the query. Specified as epoch time, the number of seconds since <code>January 1, 1970, 00:00:00 UTC</code>.</p>
     pub fn end_time(&self) -> ::std::option::Option<i64> {
         self.end_time
-65
+    }
     /// <p>The query string to use. For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html">CloudWatch Logs Insights Query Syntax</a>.</p>
     pub fn query_string(&self) -> ::std::option::Option<&str> {
         self.query_string.as_deref()
-69
+    }
     /// <p>The maximum number of log events to return in the query. If the query string uses the <code>fields</code> command, only the specified fields and their values are returned. The default is 10,000.</p>
     pub fn limit(&self) -> ::std::option::Option<i32> {
         self.limit
-73
+    }
-74
+}
 static STARTQUERYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "StartQueryInput",
 );
 static STARTQUERYINPUT_MEMBER_QUERY_LANGUAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$queryLanguage",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "query_language",
     "queryLanguage",
 ,
 );
 static STARTQUERYINPUT_MEMBER_LOG_GROUP_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$logGroupName",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "log_group_name",
     "logGroupName",
 ,
 );
 static STARTQUERYINPUT_MEMBER_LOG_GROUP_NAMES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$logGroupNames",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "log_group_names",
     "logGroupNames",
 ,
 );
 static STARTQUERYINPUT_MEMBER_LOG_GROUP_IDENTIFIERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$logGroupIdentifiers",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "log_group_identifiers",
     "logGroupIdentifiers",
 ,
 );
 static STARTQUERYINPUT_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$startTime",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "start_time",
     "startTime",
 ,
 );
 static STARTQUERYINPUT_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$endTime",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "end_time",
     "endTime",
 ,
 );
 static STARTQUERYINPUT_MEMBER_QUERY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$queryString",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "query_string",
     "queryString",
 ,
 );
 static STARTQUERYINPUT_MEMBER_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryInput$limit",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "limit",

↧ Expand context

 ,
 );
 static STARTQUERYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTQUERYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTQUERYINPUT_MEMBER_QUERY_LANGUAGE,
         &STARTQUERYINPUT_MEMBER_LOG_GROUP_NAME,
         &STARTQUERYINPUT_MEMBER_LOG_GROUP_NAMES,
         &STARTQUERYINPUT_MEMBER_LOG_GROUP_IDENTIFIERS,
         &STARTQUERYINPUT_MEMBER_START_TIME,
         &STARTQUERYINPUT_MEMBER_END_TIME,
         &STARTQUERYINPUT_MEMBER_QUERY_STRING,
         &STARTQUERYINPUT_MEMBER_LIMIT,
     ],
 );
 impl StartQueryInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTQUERYINPUT_SCHEMA;
-177
+}

@@ -199,199 +325,319 @@

↥ Expand context

             )?;
-200
+        }
         if let Some(ref val) = self.log_group_identifiers {
             ser.write_list(
                 &STARTQUERYINPUT_MEMBER_LOG_GROUP_IDENTIFIERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-207
+                    }
                     Ok(())
                 },
             )?;
-211
+        }
         if let Some(ref val) = self.start_time {
             ser.write_long(&STARTQUERYINPUT_MEMBER_START_TIME, *val)?;
-214
+        }
         if let Some(ref val) = self.end_time {
             ser.write_long(&STARTQUERYINPUT_MEMBER_END_TIME, *val)?;
-217
+        }
         if let Some(ref val) = self.query_string {

             ser.write_string(&STARTQUERYINPUT_MEMBER_QUERY_STRING, val)?;
-220
+        }
         if let Some(ref val) = self.limit {
             ser.write_integer(&STARTQUERYINPUT_MEMBER_LIMIT, *val)?;
-223
+        }
         Ok(())
-225
+    }
-226
+}
 impl StartQueryInput {
     /// 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(&STARTQUERYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTQUERYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.query_language = Some(crate::types::QueryLanguage::from(deser.read_string(member)?.as_str()));
-245
+                }
                 Some(1) => {
                     builder.log_group_name = Some(deser.read_string(member)?);
-248
+                }
                 Some(2) => {
                     builder.log_group_names = 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_group_names = Some(deser.read_string_list(member)?);
-251
+                }
                 Some(3) => {
                     builder.log_group_identifiers = 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_group_identifiers = Some(deser.read_string_list(member)?);
-254
+                }
                 Some(4) => {
                     builder.start_time = Some(deser.read_long(member)?);
-257
+                }
                 Some(5) => {
                     builder.end_time = Some(deser.read_long(member)?);
-260
+                }
                 Some(6) => {
                     builder.query_string = Some(deser.read_string(member)?);
-263
+                }
                 Some(7) => {
                     builder.limit = Some(deser.read_integer(member)?);
-266
+                }
                 _ => {}
-268
+            }
             Ok(())
         })?;
         builder.start_time = builder.start_time.or(Some(0i64));
         builder.end_time = builder.end_time.or(Some(0i64));
         builder.query_string = builder.query_string.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-277
+    }
-278
+}
 impl StartQueryInput {
     /// 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 StartQueryInput {
     /// Creates a new builder-style object to manufacture [`StartQueryInput`](crate::operation::start_query::StartQueryInput).
     pub fn builder() -> crate::operation::start_query::builders::StartQueryInputBuilder {
         crate::operation::start_query::builders::StartQueryInputBuilder::default()
-294
+    }
-295
+}
-296
 /// A builder for [`StartQueryInput`](crate::operation::start_query::StartQueryInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct StartQueryInputBuilder {
     pub(crate) query_language: ::std::option::Option<crate::types::QueryLanguage>,
     pub(crate) log_group_name: ::std::option::Option<::std::string::String>,
     pub(crate) log_group_names: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) log_group_identifiers: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) start_time: ::std::option::Option<i64>,
     pub(crate) end_time: ::std::option::Option<i64>,
     pub(crate) query_string: ::std::option::Option<::std::string::String>,
     pub(crate) limit: ::std::option::Option<i32>,
-309
+}
 impl StartQueryInputBuilder {
     /// <p>Specify the query language to use for this query. The options are Logs Insights QL, OpenSearch PPL, and OpenSearch SQL. For more information about the query languages that CloudWatch Logs supports, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_Languages.html">Supported query languages</a>.</p>
     pub fn query_language(mut self, input: crate::types::QueryLanguage) -> Self {
         self.query_language = ::std::option::Option::Some(input);
         self
-315
+    }
     /// <p>Specify the query language to use for this query. The options are Logs Insights QL, OpenSearch PPL, and OpenSearch SQL. For more information about the query languages that CloudWatch Logs supports, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_Languages.html">Supported query languages</a>.</p>
     pub fn set_query_language(mut self, input: ::std::option::Option<crate::types::QueryLanguage>) -> Self {
         self.query_language = input;
         self

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

@@ -1,1 +96,140 @@

↥ 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 StartQueryOutput {
     /// <p>The unique ID of the query.</p>
     pub query_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-9
+}
 impl StartQueryOutput {
     /// <p>The unique ID of the query.</p>
     pub fn query_id(&self) -> ::std::option::Option<&str> {
         self.query_id.as_deref()
-14
+    }
-15
+}
 static STARTQUERYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.cloudwatchlogs.synthetic#StartQueryOutput",

     "com.amazonaws.cloudwatchlogs.synthetic",
     "StartQueryOutput",
 );
 static STARTQUERYOUTPUT_MEMBER_QUERY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.cloudwatchlogs.synthetic#StartQueryOutput$queryId",
         "com.amazonaws.cloudwatchlogs.synthetic",
         "StartQueryOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "query_id",
     "queryId",
 ,
 );
 static STARTQUERYOUTPUT_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 STARTQUERYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTQUERYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&STARTQUERYOUTPUT_MEMBER_QUERY_ID],
     &[&STARTQUERYOUTPUT_MEMBER_QUERY_ID, &STARTQUERYOUTPUT_MEMBER__REQUEST_ID],
 );
 impl StartQueryOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTQUERYOUTPUT_SCHEMA;
-46
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartQueryOutput {
     #[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.query_id {
             ser.write_string(&STARTQUERYOUTPUT_MEMBER_QUERY_ID, val)?;
-55
+        }
         Ok(())
-57
+    }
-58
+}
 impl StartQueryOutput {
     /// 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(&STARTQUERYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTQUERYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.query_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl StartQueryOutput {
     /// 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(&STARTQUERYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.query_id = Some(deser.read_string(member)?);
-114
+                }
                 _ => {}
-116
+            }
             Ok(())
         })?;
         Ok(builder.build())
-120
+    }

↧ Expand context

-121
+}
 impl ::aws_types::request_id::RequestId for StartQueryOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-125
+    }
-126
+}
 impl StartQueryOutput {
     /// Creates a new builder-style object to manufacture [`StartQueryOutput`](crate::operation::start_query::StartQueryOutput).
     pub fn builder() -> crate::operation::start_query::builders::StartQueryOutputBuilder {
         crate::operation::start_query::builders::StartQueryOutputBuilder::default()
-131
+    }
-132
+}
-133
 /// A builder for [`StartQueryOutput`](crate::operation::start_query::StartQueryOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartQueryOutputBuilder {
     pub(crate) query_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-140
+}

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: