AWS SDK

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/put_configuration_aggregator/_put_configuration_aggregator_input.rs

@@ -25,25 +242,248 @@

     pub fn account_aggregation_sources(&self) -> &[crate::types::AccountAggregationSource] {
         self.account_aggregation_sources.as_deref().unwrap_or_default()
-27
+    }
     /// <p>An OrganizationAggregationSource object.</p>
     pub fn organization_aggregation_source(&self) -> ::std::option::Option<&crate::types::OrganizationAggregationSource> {
         self.organization_aggregation_source.as_ref()
-31
+    }
     /// <p>An array of tag object.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-37
+    }
     /// <p>An object to filter configuration recorders in an aggregator. Either <code>ResourceType</code> or <code>ServicePrincipal</code> is required.</p>
     pub fn aggregator_filters(&self) -> ::std::option::Option<&crate::types::AggregatorFilters> {
         self.aggregator_filters.as_ref()
-41
+    }
-42
+}
 static PUTCONFIGURATIONAGGREGATORINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorInput",

     "com.amazonaws.configservice.synthetic",
     "PutConfigurationAggregatorInput",
 );
 static PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_CONFIGURATION_AGGREGATOR_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorInput$ConfigurationAggregatorName",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationAggregatorInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "configuration_aggregator_name",
     "ConfigurationAggregatorName",
 ,
 );
 static PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_ACCOUNT_AGGREGATION_SOURCES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorInput$AccountAggregationSources",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationAggregatorInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "account_aggregation_sources",
     "AccountAggregationSources",
 ,
 );
 static PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_ORGANIZATION_AGGREGATION_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorInput$OrganizationAggregationSource",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationAggregatorInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "organization_aggregation_source",
     "OrganizationAggregationSource",
 ,
 );
 static PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorInput$Tags",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationAggregatorInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_AGGREGATOR_FILTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorInput$AggregatorFilters",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationAggregatorInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "aggregator_filters",
     "AggregatorFilters",
 ,
 );
 static PUTCONFIGURATIONAGGREGATORINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTCONFIGURATIONAGGREGATORINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_CONFIGURATION_AGGREGATOR_NAME,
         &PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_ACCOUNT_AGGREGATION_SOURCES,
         &PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_ORGANIZATION_AGGREGATION_SOURCE,
         &PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_TAGS,
         &PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_AGGREGATOR_FILTERS,
     ],
 );
 impl PutConfigurationAggregatorInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTCONFIGURATIONAGGREGATORINPUT_SCHEMA;
-112
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutConfigurationAggregatorInput {
     #[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.configuration_aggregator_name {
             ser.write_string(&PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_CONFIGURATION_AGGREGATOR_NAME, val)?;
-121
+        }
         if let Some(ref val) = self.account_aggregation_sources {
             ser.write_list(
                 &PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_ACCOUNT_AGGREGATION_SOURCES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::AccountAggregationSource::SCHEMA, item)?;
-128
+                    }
                     Ok(())
                 },
             )?;
-132
+        }
         if let Some(ref val) = self.organization_aggregation_source {
             ser.write_struct(&PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_ORGANIZATION_AGGREGATION_SOURCE, val)?;
-135
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-142
+                    }
                     Ok(())
                 },
             )?;
-146
+        }
         if let Some(ref val) = self.aggregator_filters {
             ser.write_struct(&PUTCONFIGURATIONAGGREGATORINPUT_MEMBER_AGGREGATOR_FILTERS, val)?;
-149
+        }
         Ok(())
-151
+    }
-152
+}
 impl PutConfigurationAggregatorInput {
     /// 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(&PUTCONFIGURATIONAGGREGATORINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTCONFIGURATIONAGGREGATORINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.configuration_aggregator_name = Some(deser.read_string(member)?);
-171
+                }
                 Some(1) => {
                     builder.account_aggregation_sources = 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::AccountAggregationSource::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::AccountAggregationSource::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-181
+                }
                 Some(2) => {
                     builder.organization_aggregation_source = Some(crate::types::OrganizationAggregationSource::deserialize(deser)?);
-184
+                }
                 Some(3) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-194
+                }
                 Some(4) => {
                     builder.aggregator_filters = Some(crate::types::AggregatorFilters::deserialize(deser)?);
-197
+                }
                 _ => {}
-199
+            }
             Ok(())
         })?;
         builder.configuration_aggregator_name = builder.configuration_aggregator_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-206
+    }
-207
+}
 impl PutConfigurationAggregatorInput {
     /// 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 PutConfigurationAggregatorInput {
     /// Creates a new builder-style object to manufacture [`PutConfigurationAggregatorInput`](crate::operation::put_configuration_aggregator::PutConfigurationAggregatorInput).
     pub fn builder() -> crate::operation::put_configuration_aggregator::builders::PutConfigurationAggregatorInputBuilder {
         crate::operation::put_configuration_aggregator::builders::PutConfigurationAggregatorInputBuilder::default()
-223
+    }
-224
+}
-225
 /// A builder for [`PutConfigurationAggregatorInput`](crate::operation::put_configuration_aggregator::PutConfigurationAggregatorInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutConfigurationAggregatorInputBuilder {
     pub(crate) configuration_aggregator_name: ::std::option::Option<::std::string::String>,
     pub(crate) account_aggregation_sources: ::std::option::Option<::std::vec::Vec<crate::types::AccountAggregationSource>>,
     pub(crate) organization_aggregation_source: ::std::option::Option<crate::types::OrganizationAggregationSource>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
     pub(crate) aggregator_filters: ::std::option::Option<crate::types::AggregatorFilters>,
-235
+}
 impl PutConfigurationAggregatorInputBuilder {
     /// <p>The name of the configuration aggregator.</p>
     /// This field is required.
     pub fn configuration_aggregator_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.configuration_aggregator_name = ::std::option::Option::Some(input.into());
         self
-242
+    }
     /// <p>The name of the configuration aggregator.</p>
     pub fn set_configuration_aggregator_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.configuration_aggregator_name = input;
         self
-247
+    }
     /// <p>The name of the configuration aggregator.</p>

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/put_configuration_aggregator/_put_configuration_aggregator_output.rs

@@ -1,1 +96,143 @@

↥ 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 PutConfigurationAggregatorOutput {
     /// <p>Returns a ConfigurationAggregator object.</p>
     pub configuration_aggregator: ::std::option::Option<crate::types::ConfigurationAggregator>,
     _request_id: Option<String>,
-9
+}
 impl PutConfigurationAggregatorOutput {
     /// <p>Returns a ConfigurationAggregator object.</p>
     pub fn configuration_aggregator(&self) -> ::std::option::Option<&crate::types::ConfigurationAggregator> {
         self.configuration_aggregator.as_ref()
-14
+    }
-15
+}
 static PUTCONFIGURATIONAGGREGATOROUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorOutput",

     "com.amazonaws.configservice.synthetic",
     "PutConfigurationAggregatorOutput",
 );
 static PUTCONFIGURATIONAGGREGATOROUTPUT_MEMBER_CONFIGURATION_AGGREGATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationAggregatorOutput$ConfigurationAggregator",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationAggregatorOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "configuration_aggregator",
     "ConfigurationAggregator",
 ,
 );
 static PUTCONFIGURATIONAGGREGATOROUTPUT_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 PUTCONFIGURATIONAGGREGATOROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTCONFIGURATIONAGGREGATOROUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTCONFIGURATIONAGGREGATOROUTPUT_MEMBER_CONFIGURATION_AGGREGATOR],
     &[
         &PUTCONFIGURATIONAGGREGATOROUTPUT_MEMBER_CONFIGURATION_AGGREGATOR,
         &PUTCONFIGURATIONAGGREGATOROUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl PutConfigurationAggregatorOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTCONFIGURATIONAGGREGATOROUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutConfigurationAggregatorOutput {
     #[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.configuration_aggregator {
             ser.write_struct(&PUTCONFIGURATIONAGGREGATOROUTPUT_MEMBER_CONFIGURATION_AGGREGATOR, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl PutConfigurationAggregatorOutput {
     /// 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(&PUTCONFIGURATIONAGGREGATOROUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTCONFIGURATIONAGGREGATOROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.configuration_aggregator = Some(crate::types::ConfigurationAggregator::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl PutConfigurationAggregatorOutput {
     /// 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(&PUTCONFIGURATIONAGGREGATOROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.configuration_aggregator = Some(crate::types::ConfigurationAggregator::deserialize(deser)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

-124
+}
 impl ::aws_types::request_id::RequestId for PutConfigurationAggregatorOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-128
+    }
-129
+}
 impl PutConfigurationAggregatorOutput {
     /// Creates a new builder-style object to manufacture [`PutConfigurationAggregatorOutput`](crate::operation::put_configuration_aggregator::PutConfigurationAggregatorOutput).
     pub fn builder() -> crate::operation::put_configuration_aggregator::builders::PutConfigurationAggregatorOutputBuilder {
         crate::operation::put_configuration_aggregator::builders::PutConfigurationAggregatorOutputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`PutConfigurationAggregatorOutput`](crate::operation::put_configuration_aggregator::PutConfigurationAggregatorOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutConfigurationAggregatorOutputBuilder {
     pub(crate) configuration_aggregator: ::std::option::Option<crate::types::ConfigurationAggregator>,
     _request_id: Option<String>,
-143
+}

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/put_configuration_recorder.rs

@@ -1,1 +40,46 @@

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

@@ -124,130 +253,426 @@

↥ Expand context

         });
-131
         ::std::option::Option::Some(cfg.freeze())
-133
+    }
-134
     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("PutConfigurationRecorder")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutConfigurationRecorderEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_configuration_recorder::PutConfigurationRecorderError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_configuration_recorder::PutConfigurationRecorderError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::put_configuration_recorder::PutConfigurationRecorderError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct PutConfigurationRecorderResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutConfigurationRecorderResponseDeserializer {
     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_configuration_recorder::de_put_configuration_recorder_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::put_configuration_recorder::PutConfigurationRecorderError::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 {
                 "InvalidConfigurationRecorderNameException" => {
                     crate::operation::put_configuration_recorder::PutConfigurationRecorderError::InvalidConfigurationRecorderNameException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidConfigurationRecorderNameException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidConfigurationRecorderNameException::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
                     })
-+
+                }
                 "InvalidRecordingGroupException" => {
                     crate::operation::put_configuration_recorder::PutConfigurationRecorderError::InvalidRecordingGroupException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidRecordingGroupException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidRecordingGroupException::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
                     })
-+
+                }
                 "InvalidRoleException" => crate::operation::put_configuration_recorder::PutConfigurationRecorderError::InvalidRoleException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidRoleException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidRoleException::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
                 }),
                 "MaxNumberOfConfigurationRecordersExceededException" => {
                     crate::operation::put_configuration_recorder::PutConfigurationRecorderError::MaxNumberOfConfigurationRecordersExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(
                                 response,
                                 crate::types::error::MaxNumberOfConfigurationRecordersExceededException::SCHEMA,
                                 _cfg,
-+
+                            )
                             .and_then(|mut deser| {
                                 crate::types::error::MaxNumberOfConfigurationRecordersExceededException::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
                     })
-+
+                }
                 "UnmodifiableEntityException" => {
                     crate::operation::put_configuration_recorder::PutConfigurationRecorderError::UnmodifiableEntityException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::UnmodifiableEntityException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::UnmodifiableEntityException::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
                     })
-+
+                }
                 "ValidationException" => crate::operation::put_configuration_recorder::PutConfigurationRecorderError::ValidationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationException::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_configuration_recorder::PutConfigurationRecorderError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_put_configuration_recorder::de_put_configuration_recorder_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, PutConfigurationRecorder::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_configuration_recorder::PutConfigurationRecorderOutput::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))
-+
+        }
-375
+    }
-376
+}
 #[derive(Debug)]
 struct PutConfigurationRecorderRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutConfigurationRecorderRequestSerializer {
     #[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_configuration_recorder::PutConfigurationRecorderInput>()
             .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_configuration_recorder::PutConfigurationRecorderInput,
                 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_configuration_recorder::PutConfigurationRecorderInput,
                 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"),
                 "StarlingDoveService.PutConfigurationRecorder",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_put_configuration_recorder::ser_put_configuration_recorder_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, PutConfigurationRecorder::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-397
+    }
-398
+}
 #[derive(Debug)]
 struct PutConfigurationRecorderEndpointParamsInterceptor;
-401
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutConfigurationRecorderEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutConfigurationRecorderEndpointParamsInterceptor"
-405
+    }
-406

↧ 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::<PutConfigurationRecorderInput>()
             .ok_or("failed to downcast to PutConfigurationRecorderInput")?;
-421
         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/config/src/operation/put_configuration_recorder/_put_configuration_recorder_input.rs

@@ -6,6 +154,162 @@

↥ Expand context

 pub struct PutConfigurationRecorderInput {
     /// <p>An object for the configuration recorder. A configuration recorder records configuration changes for the resource types in scope.</p>
     pub configuration_recorder: ::std::option::Option<crate::types::ConfigurationRecorder>,
     /// <p>The tags for the customer managed configuration recorder. Each tag consists of a key and an optional value, both of which you define.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-11
+}
 impl PutConfigurationRecorderInput {
     /// <p>An object for the configuration recorder. A configuration recorder records configuration changes for the resource types in scope.</p>
     pub fn configuration_recorder(&self) -> ::std::option::Option<&crate::types::ConfigurationRecorder> {
         self.configuration_recorder.as_ref()
-16
+    }
     /// <p>The tags for the customer managed configuration recorder. Each tag consists of a key and an optional value, both of which you define.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-22
+    }
-23
+}
 static PUTCONFIGURATIONRECORDERINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice.synthetic#PutConfigurationRecorderInput",

     "com.amazonaws.configservice.synthetic",
     "PutConfigurationRecorderInput",
 );
 static PUTCONFIGURATIONRECORDERINPUT_MEMBER_CONFIGURATION_RECORDER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationRecorderInput$ConfigurationRecorder",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationRecorderInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "configuration_recorder",
     "ConfigurationRecorder",
 ,
 );
 static PUTCONFIGURATIONRECORDERINPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConfigurationRecorderInput$Tags",
         "com.amazonaws.configservice.synthetic",
         "PutConfigurationRecorderInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "tags",
     "Tags",
 ,
 );
 static PUTCONFIGURATIONRECORDERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTCONFIGURATIONRECORDERINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTCONFIGURATIONRECORDERINPUT_MEMBER_CONFIGURATION_RECORDER,
         &PUTCONFIGURATIONRECORDERINPUT_MEMBER_TAGS,
     ],
 );
 impl PutConfigurationRecorderInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTCONFIGURATIONRECORDERINPUT_SCHEMA;
-60
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutConfigurationRecorderInput {
     #[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.configuration_recorder {
             ser.write_struct(&PUTCONFIGURATIONRECORDERINPUT_MEMBER_CONFIGURATION_RECORDER, val)?;
-69
+        }
         if let Some(ref val) = self.tags {
             ser.write_list(
                 &PUTCONFIGURATIONRECORDERINPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Tag::SCHEMA, item)?;
-76
+                    }
                     Ok(())
                 },
             )?;
-80
+        }
         Ok(())
-82
+    }
-83
+}
 impl PutConfigurationRecorderInput {
     /// 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(&PUTCONFIGURATIONRECORDERINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTCONFIGURATIONRECORDERINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.configuration_recorder = Some(crate::types::ConfigurationRecorder::deserialize(deser)?);
-102
+                }
                 Some(1) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Tag::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Tag::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-112
+                }
                 _ => {}
-114
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-120
+    }
-121
+}
 impl PutConfigurationRecorderInput {
     /// 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 PutConfigurationRecorderInput {
     /// Creates a new builder-style object to manufacture [`PutConfigurationRecorderInput`](crate::operation::put_configuration_recorder::PutConfigurationRecorderInput).
     pub fn builder() -> crate::operation::put_configuration_recorder::builders::PutConfigurationRecorderInputBuilder {
         crate::operation::put_configuration_recorder::builders::PutConfigurationRecorderInputBuilder::default()
-137
+    }
-138
+}
-139
 /// A builder for [`PutConfigurationRecorderInput`](crate::operation::put_configuration_recorder::PutConfigurationRecorderInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutConfigurationRecorderInputBuilder {
     pub(crate) configuration_recorder: ::std::option::Option<crate::types::ConfigurationRecorder>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-146
+}
 impl PutConfigurationRecorderInputBuilder {
     /// <p>An object for the configuration recorder. A configuration recorder records configuration changes for the resource types in scope.</p>
     /// This field is required.
     pub fn configuration_recorder(mut self, input: crate::types::ConfigurationRecorder) -> Self {
         self.configuration_recorder = ::std::option::Option::Some(input);
         self
-153
+    }
     /// <p>An object for the configuration recorder. A configuration recorder records configuration changes for the resource types in scope.</p>
     pub fn set_configuration_recorder(mut self, input: ::std::option::Option<crate::types::ConfigurationRecorder>) -> Self {
         self.configuration_recorder = input;
         self
-158
+    }
     /// <p>An object for the configuration recorder. A configuration recorder records configuration changes for the resource types in scope.</p>
     pub fn get_configuration_recorder(&self) -> &::std::option::Option<crate::types::ConfigurationRecorder> {
         &self.configuration_recorder
-162
+    }

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/put_configuration_recorder/_put_configuration_recorder_output.rs

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

↥ Expand context

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

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/put_conformance_pack.rs

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

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

@@ -118,122 +246,390 @@

↥ 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("PutConformancePack")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutConformancePackEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_conformance_pack::PutConformancePackError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_conformance_pack::PutConformancePackError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::put_conformance_pack::PutConformancePackError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct PutConformancePackResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutConformancePackResponseDeserializer {
     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_conformance_pack::de_put_conformance_pack_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::put_conformance_pack::PutConformancePackError::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 {
                 "ConformancePackTemplateValidationException" => {
                     crate::operation::put_conformance_pack::PutConformancePackError::ConformancePackTemplateValidationException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ConformancePackTemplateValidationException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ConformancePackTemplateValidationException::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
                     })
-+
+                }
                 "InsufficientPermissionsException" => {
                     crate::operation::put_conformance_pack::PutConformancePackError::InsufficientPermissionsException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InsufficientPermissionsException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InsufficientPermissionsException::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
                     })
-+
+                }
                 "InvalidParameterValueException" => {
                     crate::operation::put_conformance_pack::PutConformancePackError::InvalidParameterValueException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidParameterValueException::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
                     })
-+
+                }
                 "MaxNumberOfConformancePacksExceededException" => {
                     crate::operation::put_conformance_pack::PutConformancePackError::MaxNumberOfConformancePacksExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::MaxNumberOfConformancePacksExceededException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::MaxNumberOfConformancePacksExceededException::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
                     })
-+
+                }
                 "ResourceInUseException" => crate::operation::put_conformance_pack::PutConformancePackError::ResourceInUseException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceInUseException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceInUseException::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_conformance_pack::PutConformancePackError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_put_conformance_pack::de_put_conformance_pack_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, PutConformancePack::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_conformance_pack::PutConformancePackOutput::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))
-+
+        }
-339
+    }
-340
+}
 #[derive(Debug)]
 struct PutConformancePackRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutConformancePackRequestSerializer {
     #[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_conformance_pack::PutConformancePackInput>()
             .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_conformance_pack::PutConformancePackInput,
                 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_conformance_pack::PutConformancePackInput,
                 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"),
                 "StarlingDoveService.PutConformancePack",
             );
             builder
         };
         let body =
             ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_conformance_pack::ser_put_conformance_pack_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, PutConformancePack::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-361
+    }
-362
+}
 #[derive(Debug)]
 struct PutConformancePackEndpointParamsInterceptor;
-365
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutConformancePackEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutConformancePackEndpointParamsInterceptor"
-369
+    }
-370

↧ 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::<PutConformancePackInput>()
             .ok_or("failed to downcast to PutConformancePackInput")?;
-385
         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/config/src/operation/put_conformance_pack/_put_conformance_pack_input.rs

@@ -51,51 +284,293 @@

↥ Expand context

-51
+    }
     /// <p>The prefix for the Amazon S3 bucket.</p><note>
     /// <p>This field is optional.</p>
     /// </note>
     pub fn delivery_s3_key_prefix(&self) -> ::std::option::Option<&str> {
         self.delivery_s3_key_prefix.as_deref()
-57
+    }
     /// <p>A list of <code>ConformancePackInputParameter</code> objects.</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 `.conformance_pack_input_parameters.is_none()`.
     pub fn conformance_pack_input_parameters(&self) -> &[crate::types::ConformancePackInputParameter] {
         self.conformance_pack_input_parameters.as_deref().unwrap_or_default()
-63
+    }
     /// <p>An object of type <code>TemplateSSMDocumentDetails</code>, which contains the name or the Amazon Resource Name (ARN) of the Amazon Web Services Systems Manager document (SSM document) and the version of the SSM document that is used to create a conformance pack.</p>
     pub fn template_ssm_document_details(&self) -> ::std::option::Option<&crate::types::TemplateSsmDocumentDetails> {
         self.template_ssm_document_details.as_ref()
-67
+    }
-68
+}
 static PUTCONFORMANCEPACKINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice.synthetic#PutConformancePackInput",

     "com.amazonaws.configservice.synthetic",
     "PutConformancePackInput",
 );
 static PUTCONFORMANCEPACKINPUT_MEMBER_CONFORMANCE_PACK_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackInput$ConformancePackName",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "conformance_pack_name",
     "ConformancePackName",
 ,
 );
 static PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_S3_URI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackInput$TemplateS3Uri",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "template_s3_uri",
     "TemplateS3Uri",
 ,
 );
 static PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackInput$TemplateBody",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "template_body",
     "TemplateBody",
 ,
 );
 static PUTCONFORMANCEPACKINPUT_MEMBER_DELIVERY_S3_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackInput$DeliveryS3Bucket",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "delivery_s3_bucket",
     "DeliveryS3Bucket",
 ,
 );
 static PUTCONFORMANCEPACKINPUT_MEMBER_DELIVERY_S3_KEY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackInput$DeliveryS3KeyPrefix",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "delivery_s3_key_prefix",
     "DeliveryS3KeyPrefix",
 ,
 );
 static PUTCONFORMANCEPACKINPUT_MEMBER_CONFORMANCE_PACK_INPUT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackInput$ConformancePackInputParameters",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "conformance_pack_input_parameters",
     "ConformancePackInputParameters",
 ,
 );
 static PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_SSM_DOCUMENT_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackInput$TemplateSSMDocumentDetails",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "template_ssm_document_details",
     "TemplateSSMDocumentDetails",
 ,
 );
 static PUTCONFORMANCEPACKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTCONFORMANCEPACKINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTCONFORMANCEPACKINPUT_MEMBER_CONFORMANCE_PACK_NAME,
         &PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_S3_URI,
         &PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_BODY,
         &PUTCONFORMANCEPACKINPUT_MEMBER_DELIVERY_S3_BUCKET,
         &PUTCONFORMANCEPACKINPUT_MEMBER_DELIVERY_S3_KEY_PREFIX,
         &PUTCONFORMANCEPACKINPUT_MEMBER_CONFORMANCE_PACK_INPUT_PARAMETERS,
         &PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_SSM_DOCUMENT_DETAILS,
     ],
 );
 impl PutConformancePackInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTCONFORMANCEPACKINPUT_SCHEMA;
-160
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutConformancePackInput {
     #[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.conformance_pack_name {
             ser.write_string(&PUTCONFORMANCEPACKINPUT_MEMBER_CONFORMANCE_PACK_NAME, val)?;
-169
+        }
         if let Some(ref val) = self.template_s3_uri {
             ser.write_string(&PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_S3_URI, val)?;
-172
+        }
         if let Some(ref val) = self.template_body {
             ser.write_string(&PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_BODY, val)?;
-175
+        }
         if let Some(ref val) = self.delivery_s3_bucket {
             ser.write_string(&PUTCONFORMANCEPACKINPUT_MEMBER_DELIVERY_S3_BUCKET, val)?;
-178
+        }
         if let Some(ref val) = self.delivery_s3_key_prefix {
             ser.write_string(&PUTCONFORMANCEPACKINPUT_MEMBER_DELIVERY_S3_KEY_PREFIX, val)?;
-181
+        }
         if let Some(ref val) = self.conformance_pack_input_parameters {
             ser.write_list(
                 &PUTCONFORMANCEPACKINPUT_MEMBER_CONFORMANCE_PACK_INPUT_PARAMETERS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ConformancePackInputParameter::SCHEMA, item)?;
-188
+                    }
                     Ok(())
                 },
             )?;
-192
+        }
         if let Some(ref val) = self.template_ssm_document_details {
             ser.write_struct(&PUTCONFORMANCEPACKINPUT_MEMBER_TEMPLATE_SSM_DOCUMENT_DETAILS, val)?;
-195
+        }
         Ok(())
-197
+    }
-198
+}
 impl PutConformancePackInput {
     /// 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(&PUTCONFORMANCEPACKINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTCONFORMANCEPACKINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.conformance_pack_name = Some(deser.read_string(member)?);
-217
+                }
                 Some(1) => {
                     builder.template_s3_uri = Some(deser.read_string(member)?);
-220
+                }
                 Some(2) => {
                     builder.template_body = Some(deser.read_string(member)?);
-223
+                }
                 Some(3) => {
                     builder.delivery_s3_bucket = Some(deser.read_string(member)?);
-226
+                }
                 Some(4) => {
                     builder.delivery_s3_key_prefix = Some(deser.read_string(member)?);
-229
+                }
                 Some(5) => {
                     builder.conformance_pack_input_parameters = 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::ConformancePackInputParameter::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ConformancePackInputParameter::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-239
+                }
                 Some(6) => {
                     builder.template_ssm_document_details = Some(crate::types::TemplateSsmDocumentDetails::deserialize(deser)?);
-242
+                }
                 _ => {}
-244
+            }
             Ok(())
         })?;
         builder.conformance_pack_name = builder.conformance_pack_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-251
+    }
-252
+}
 impl PutConformancePackInput {
     /// 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 PutConformancePackInput {
     /// Creates a new builder-style object to manufacture [`PutConformancePackInput`](crate::operation::put_conformance_pack::PutConformancePackInput).
     pub fn builder() -> crate::operation::put_conformance_pack::builders::PutConformancePackInputBuilder {
         crate::operation::put_conformance_pack::builders::PutConformancePackInputBuilder::default()
-268
+    }
-269
+}
-270
 /// A builder for [`PutConformancePackInput`](crate::operation::put_conformance_pack::PutConformancePackInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutConformancePackInputBuilder {
     pub(crate) conformance_pack_name: ::std::option::Option<::std::string::String>,
     pub(crate) template_s3_uri: ::std::option::Option<::std::string::String>,
     pub(crate) template_body: ::std::option::Option<::std::string::String>,
     pub(crate) delivery_s3_bucket: ::std::option::Option<::std::string::String>,
     pub(crate) delivery_s3_key_prefix: ::std::option::Option<::std::string::String>,
     pub(crate) conformance_pack_input_parameters: ::std::option::Option<::std::vec::Vec<crate::types::ConformancePackInputParameter>>,
     pub(crate) template_ssm_document_details: ::std::option::Option<crate::types::TemplateSsmDocumentDetails>,
-282
+}
 impl PutConformancePackInputBuilder {
     /// <p>The unique name of the conformance pack you want to deploy.</p>
     /// This field is required.
     pub fn conformance_pack_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.conformance_pack_name = ::std::option::Option::Some(input.into());
         self
-289
+    }
     /// <p>The unique name of the conformance pack you want to deploy.</p>
     pub fn set_conformance_pack_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.conformance_pack_name = input;
         self

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/put_conformance_pack/_put_conformance_pack_output.rs

@@ -1,1 +96,143 @@

↥ 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 PutConformancePackOutput {
     /// <p>ARN of the conformance pack.</p>
     pub conformance_pack_arn: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-9
+}
 impl PutConformancePackOutput {
     /// <p>ARN of the conformance pack.</p>
     pub fn conformance_pack_arn(&self) -> ::std::option::Option<&str> {
         self.conformance_pack_arn.as_deref()
-14
+    }
-15
+}
 static PUTCONFORMANCEPACKOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.configservice.synthetic#PutConformancePackOutput",

     "com.amazonaws.configservice.synthetic",
     "PutConformancePackOutput",
 );
 static PUTCONFORMANCEPACKOUTPUT_MEMBER_CONFORMANCE_PACK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.configservice.synthetic#PutConformancePackOutput$ConformancePackArn",
         "com.amazonaws.configservice.synthetic",
         "PutConformancePackOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "conformance_pack_arn",
     "ConformancePackArn",
 ,
 );
 static PUTCONFORMANCEPACKOUTPUT_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 PUTCONFORMANCEPACKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTCONFORMANCEPACKOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTCONFORMANCEPACKOUTPUT_MEMBER_CONFORMANCE_PACK_ARN],
     &[
         &PUTCONFORMANCEPACKOUTPUT_MEMBER_CONFORMANCE_PACK_ARN,
         &PUTCONFORMANCEPACKOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl PutConformancePackOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTCONFORMANCEPACKOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutConformancePackOutput {
     #[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.conformance_pack_arn {
             ser.write_string(&PUTCONFORMANCEPACKOUTPUT_MEMBER_CONFORMANCE_PACK_ARN, val)?;
-58
+        }
         Ok(())
-60
+    }
-61
+}
 impl PutConformancePackOutput {
     /// 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(&PUTCONFORMANCEPACKOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTCONFORMANCEPACKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.conformance_pack_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl PutConformancePackOutput {
     /// 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(&PUTCONFORMANCEPACKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.conformance_pack_arn = Some(deser.read_string(member)?);
-117
+                }
                 _ => {}
-119
+            }
             Ok(())
         })?;
         Ok(builder.build())
-123
+    }

↧ Expand context

-124
+}
 impl ::aws_types::request_id::RequestId for PutConformancePackOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-128
+    }
-129
+}
 impl PutConformancePackOutput {
     /// Creates a new builder-style object to manufacture [`PutConformancePackOutput`](crate::operation::put_conformance_pack::PutConformancePackOutput).
     pub fn builder() -> crate::operation::put_conformance_pack::builders::PutConformancePackOutputBuilder {
         crate::operation::put_conformance_pack::builders::PutConformancePackOutputBuilder::default()
-134
+    }
-135
+}
-136
 /// A builder for [`PutConformancePackOutput`](crate::operation::put_conformance_pack::PutConformancePackOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct PutConformancePackOutputBuilder {
     pub(crate) conformance_pack_arn: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-143
+}

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/put_delivery_channel.rs

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

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

@@ -118,122 +246,462 @@

↥ 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("PutDeliveryChannel")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutDeliveryChannelEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_delivery_channel::PutDeliveryChannelError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_delivery_channel::PutDeliveryChannelError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::put_delivery_channel::PutDeliveryChannelError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct PutDeliveryChannelResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutDeliveryChannelResponseDeserializer {
     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_delivery_channel::de_put_delivery_channel_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::put_delivery_channel::PutDeliveryChannelError::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 {
                 "InsufficientDeliveryPolicyException" => {
                     crate::operation::put_delivery_channel::PutDeliveryChannelError::InsufficientDeliveryPolicyException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InsufficientDeliveryPolicyException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InsufficientDeliveryPolicyException::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
                     })
-+
+                }
                 "InvalidDeliveryChannelNameException" => {
                     crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidDeliveryChannelNameException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidDeliveryChannelNameException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidDeliveryChannelNameException::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
                     })
-+
+                }
                 "InvalidS3KeyPrefixException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidS3KeyPrefixException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidS3KeyPrefixException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidS3KeyPrefixException::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
                 }),
                 "InvalidS3KmsKeyArnException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidS3KmsKeyArnException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidS3KmsKeyArnException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidS3KmsKeyArnException::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
                 }),
                 "InvalidSNSTopicARNException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::InvalidSnsTopicArnException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidSnsTopicArnException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidSnsTopicArnException::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
                 }),
                 "MaxNumberOfDeliveryChannelsExceededException" => {
                     crate::operation::put_delivery_channel::PutDeliveryChannelError::MaxNumberOfDeliveryChannelsExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::MaxNumberOfDeliveryChannelsExceededException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::MaxNumberOfDeliveryChannelsExceededException::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
                     })
-+
+                }
                 "NoAvailableConfigurationRecorderException" => {
                     crate::operation::put_delivery_channel::PutDeliveryChannelError::NoAvailableConfigurationRecorderException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::NoAvailableConfigurationRecorderException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::NoAvailableConfigurationRecorderException::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
                     })
-+
+                }
                 "NoSuchBucketException" => crate::operation::put_delivery_channel::PutDeliveryChannelError::NoSuchBucketException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::NoSuchBucketException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::NoSuchBucketException::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_delivery_channel::PutDeliveryChannelError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_put_delivery_channel::de_put_delivery_channel_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, PutDeliveryChannel::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_delivery_channel::PutDeliveryChannelOutput::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))
-+
+        }
-411
+    }
-412
+}
 #[derive(Debug)]
 struct PutDeliveryChannelRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutDeliveryChannelRequestSerializer {
     #[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_delivery_channel::PutDeliveryChannelInput>()
             .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_delivery_channel::PutDeliveryChannelInput,
                 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_delivery_channel::PutDeliveryChannelInput,
                 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"),
                 "StarlingDoveService.PutDeliveryChannel",
             );
             builder
         };
         let body =
             ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_delivery_channel::ser_put_delivery_channel_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, PutDeliveryChannel::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-433
+    }
-434
+}
 #[derive(Debug)]
 struct PutDeliveryChannelEndpointParamsInterceptor;
-437
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutDeliveryChannelEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutDeliveryChannelEndpointParamsInterceptor"
-441
+    }
-442

↧ 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::<PutDeliveryChannelInput>()
             .ok_or("failed to downcast to PutDeliveryChannelInput")?;
-457
         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()))

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: