AWS SDK

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_traffic_policy_instances_by_policy.rs

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

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

@@ -124,130 +186,193 @@

↥ 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("ListTrafficPolicyInstancesByPolicy")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListTrafficPolicyInstancesByPolicyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct ListTrafficPolicyInstancesByPolicyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListTrafficPolicyInstancesByPolicyResponseDeserializer {
     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_list_traffic_policy_instances_by_policy::de_list_traffic_policy_instances_by_policy_http_error(
                 status, headers, body,

↧ Expand context

-174
+            )
         } else {
             crate::protocol_serde::shape_list_traffic_policy_instances_by_policy::de_list_traffic_policy_instances_by_policy_http_response(
                 status, headers, body,
-178
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-181
+    }
-182
+}
 #[derive(Debug)]
 struct ListTrafficPolicyInstancesByPolicyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListTrafficPolicyInstancesByPolicyRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyInput>()

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_traffic_policy_instances_by_policy/_list_traffic_policy_instances_by_policy_input.rs

@@ -40,40 +249,267 @@

↥ Expand context

-40
+    }
     /// <p>If the value of <code>IsTruncated</code> in the previous response was <code>true</code>, you have more traffic policy instances. To get more traffic policy instances, submit another <code>ListTrafficPolicyInstancesByPolicy</code> request.</p>
     /// <p>For the value of <code>trafficpolicyinstancename</code>, specify the value of <code>TrafficPolicyInstanceNameMarker</code> from the previous response, which is the name of the first traffic policy instance that Amazon Route 53 will return if you submit another request.</p>
     /// <p>If the value of <code>IsTruncated</code> in the previous response was <code>false</code>, there are no more traffic policy instances to get.</p>
     pub fn traffic_policy_instance_name_marker(&self) -> ::std::option::Option<&str> {
         self.traffic_policy_instance_name_marker.as_deref()
-46
+    }
     /// <p>If the value of <code>IsTruncated</code> in the previous response was <code>true</code>, you have more traffic policy instances. To get more traffic policy instances, submit another <code>ListTrafficPolicyInstancesByPolicy</code> request.</p>
     /// <p>For the value of <code>trafficpolicyinstancetype</code>, specify the value of <code>TrafficPolicyInstanceTypeMarker</code> from the previous response, which is the name of the first traffic policy instance that Amazon Route 53 will return if you submit another request.</p>
     /// <p>If the value of <code>IsTruncated</code> in the previous response was <code>false</code>, there are no more traffic policy instances to get.</p>
     pub fn traffic_policy_instance_type_marker(&self) -> ::std::option::Option<&crate::types::RrType> {
         self.traffic_policy_instance_type_marker.as_ref()
-52
+    }
     /// <p>The maximum number of traffic policy instances to be included in the response body for this request. If you have more than <code>MaxItems</code> traffic policy instances, the value of the <code>IsTruncated</code> element in the response is <code>true</code>, and the values of <code>HostedZoneIdMarker</code>, <code>TrafficPolicyInstanceNameMarker</code>, and <code>TrafficPolicyInstanceTypeMarker</code> represent the first traffic policy instance that Amazon Route 53 will return if you submit another request.</p>
     pub fn max_items(&self) -> ::std::option::Option<i32> {
         self.max_items
-56
+    }
-57
+}
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyInput",

     "com.amazonaws.route53.synthetic",
     "ListTrafficPolicyInstancesByPolicyInput",
 );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyInput$TrafficPolicyId",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyInstancesByPolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "traffic_policy_id",
     "TrafficPolicyId",
 ,
-72
+)
 .with_http_query("id");
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyInput$TrafficPolicyVersion",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyInstancesByPolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "traffic_policy_version",
     "TrafficPolicyVersion",
 ,
-83
+)
 .with_http_query("version");
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_HOSTED_ZONE_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyInput$HostedZoneIdMarker",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyInstancesByPolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hosted_zone_id_marker",
     "HostedZoneIdMarker",
 ,
-94
+)
 .with_http_query("hostedzoneid");
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_NAME_MARKER: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyInput$TrafficPolicyInstanceNameMarker",
             "com.amazonaws.route53.synthetic",
             "ListTrafficPolicyInstancesByPolicyInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "traffic_policy_instance_name_marker",
         "TrafficPolicyInstanceNameMarker",
 ,
-106
+    )
     .with_http_query("trafficpolicyinstancename");
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_TYPE_MARKER: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyInput$TrafficPolicyInstanceTypeMarker",
             "com.amazonaws.route53.synthetic",
             "ListTrafficPolicyInstancesByPolicyInput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "traffic_policy_instance_type_marker",
         "TrafficPolicyInstanceTypeMarker",
 ,
-118
+    )
     .with_http_query("trafficpolicyinstancetype");
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_MAX_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyInput$MaxItems",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyInstancesByPolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_items",
     "MaxItems",
 ,
-129
+)
 .with_http_query("maxitems");
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_ID,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_VERSION,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_HOSTED_ZONE_ID_MARKER,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_NAME_MARKER,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_TYPE_MARKER,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_MAX_ITEMS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/2013-04-01/trafficpolicyinstances/trafficpolicy",
     None,
 ));
 impl ListTrafficPolicyInstancesByPolicyInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_SCHEMA;
-151
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListTrafficPolicyInstancesByPolicyInput {
     #[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.traffic_policy_id {
             ser.write_string(&LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_ID, val)?;
-160
+        }
         if let Some(ref val) = self.traffic_policy_version {
             ser.write_integer(&LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_VERSION, *val)?;
-163
+        }
         if let Some(ref val) = self.hosted_zone_id_marker {
             ser.write_string(&LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_HOSTED_ZONE_ID_MARKER, val)?;
-166
+        }
         if let Some(ref val) = self.traffic_policy_instance_name_marker {
             ser.write_string(&LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_NAME_MARKER, val)?;
-169
+        }
         if let Some(ref val) = self.traffic_policy_instance_type_marker {
             ser.write_string(
                 &LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_TYPE_MARKER,
                 val.as_str(),
             )?;
-175
+        }
         if let Some(ref val) = self.max_items {
             ser.write_integer(&LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_MEMBER_MAX_ITEMS, *val)?;
-178
+        }
         Ok(())
-180
+    }
-181
+}
 impl ListTrafficPolicyInstancesByPolicyInput {
     /// 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(&LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTTRAFFICPOLICYINSTANCESBYPOLICYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.traffic_policy_id = Some(deser.read_string(member)?);
-200
+                }
                 Some(1) => {
                     builder.traffic_policy_version = Some(deser.read_integer(member)?);
-203
+                }
                 Some(2) => {
                     builder.hosted_zone_id_marker = Some(deser.read_string(member)?);
-206
+                }
                 Some(3) => {
                     builder.traffic_policy_instance_name_marker = Some(deser.read_string(member)?);
-209
+                }
                 Some(4) => {
                     builder.traffic_policy_instance_type_marker = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
-212
+                }
                 Some(5) => {
                     builder.max_items = Some(deser.read_integer(member)?);
-215
+                }
                 _ => {}
-217
+            }
             Ok(())
         })?;
         builder.traffic_policy_id = builder.traffic_policy_id.or(Some(String::new()));
         builder.traffic_policy_version = builder.traffic_policy_version.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-225
+    }
-226
+}
 impl ListTrafficPolicyInstancesByPolicyInput {
     /// 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 ListTrafficPolicyInstancesByPolicyInput {
     /// Creates a new builder-style object to manufacture [`ListTrafficPolicyInstancesByPolicyInput`](crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyInput).
     pub fn builder() -> crate::operation::list_traffic_policy_instances_by_policy::builders::ListTrafficPolicyInstancesByPolicyInputBuilder {
         crate::operation::list_traffic_policy_instances_by_policy::builders::ListTrafficPolicyInstancesByPolicyInputBuilder::default()
-242
+    }
-243
+}
-244
 /// A builder for [`ListTrafficPolicyInstancesByPolicyInput`](crate::operation::list_traffic_policy_instances_by_policy::ListTrafficPolicyInstancesByPolicyInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListTrafficPolicyInstancesByPolicyInputBuilder {
     pub(crate) traffic_policy_id: ::std::option::Option<::std::string::String>,
     pub(crate) traffic_policy_version: ::std::option::Option<i32>,
     pub(crate) hosted_zone_id_marker: ::std::option::Option<::std::string::String>,
     pub(crate) traffic_policy_instance_name_marker: ::std::option::Option<::std::string::String>,
     pub(crate) traffic_policy_instance_type_marker: ::std::option::Option<crate::types::RrType>,
     pub(crate) max_items: ::std::option::Option<i32>,
-255
+}
 impl ListTrafficPolicyInstancesByPolicyInputBuilder {
     /// <p>The ID of the traffic policy for which you want to list traffic policy instances.</p>
     /// This field is required.
     pub fn traffic_policy_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.traffic_policy_id = ::std::option::Option::Some(input.into());
         self
-262
+    }
     /// <p>The ID of the traffic policy for which you want to list traffic policy instances.</p>
     pub fn set_traffic_policy_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.traffic_policy_id = input;
         self
-267
+    }

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_traffic_policy_instances_by_policy/_list_traffic_policy_instances_by_policy_output.rs

@@ -31,31 +230,299 @@

↥ Expand context

     /// <p>If <code>IsTruncated</code> is <code>true</code>, <code>TrafficPolicyInstanceNameMarker</code> is the name of the first traffic policy instance in the next group of <code>MaxItems</code> traffic policy instances.</p>
     pub fn traffic_policy_instance_name_marker(&self) -> ::std::option::Option<&str> {
         self.traffic_policy_instance_name_marker.as_deref()
-34
+    }
     /// <p>If <code>IsTruncated</code> is <code>true</code>, <code>TrafficPolicyInstanceTypeMarker</code> is the DNS type of the resource record sets that are associated with the first traffic policy instance in the next group of <code>MaxItems</code> traffic policy instances.</p>
     pub fn traffic_policy_instance_type_marker(&self) -> ::std::option::Option<&crate::types::RrType> {
         self.traffic_policy_instance_type_marker.as_ref()
-38
+    }
     /// <p>A flag that indicates whether there are more traffic policy instances to be listed. If the response was truncated, you can get the next group of traffic policy instances by calling <code>ListTrafficPolicyInstancesByPolicy</code> again and specifying the values of the <code>HostedZoneIdMarker</code>, <code>TrafficPolicyInstanceNameMarker</code>, and <code>TrafficPolicyInstanceTypeMarker</code> elements in the corresponding request parameters.</p>
     pub fn is_truncated(&self) -> bool {
         self.is_truncated
-42
+    }
     /// <p>The value that you specified for the <code>MaxItems</code> parameter in the call to <code>ListTrafficPolicyInstancesByPolicy</code> that produced the current response.</p>
     pub fn max_items(&self) -> i32 {
         self.max_items
-46
+    }
-47
+}
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyOutput",
     "com.amazonaws.route53.synthetic",

     "ListTrafficPolicyInstancesByPolicyOutput",
 );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCES: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyOutput$TrafficPolicyInstances",
             "com.amazonaws.route53.synthetic",
             "ListTrafficPolicyInstancesByPolicyOutput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "traffic_policy_instances",
         "TrafficPolicyInstances",
 ,
     );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_HOSTED_ZONE_ID_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyOutput$HostedZoneIdMarker",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyInstancesByPolicyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hosted_zone_id_marker",
     "HostedZoneIdMarker",
 ,
 );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_NAME_MARKER: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyOutput$TrafficPolicyInstanceNameMarker",
             "com.amazonaws.route53.synthetic",
             "ListTrafficPolicyInstancesByPolicyOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "traffic_policy_instance_name_marker",
         "TrafficPolicyInstanceNameMarker",
 ,
     );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_TYPE_MARKER: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyOutput$TrafficPolicyInstanceTypeMarker",
             "com.amazonaws.route53.synthetic",
             "ListTrafficPolicyInstancesByPolicyOutput",
         ),
         ::aws_smithy_schema::ShapeType::String,
         "traffic_policy_instance_type_marker",
         "TrafficPolicyInstanceTypeMarker",
 ,
     );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyOutput$IsTruncated",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyInstancesByPolicyOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "is_truncated",
     "IsTruncated",
 ,
 );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_MAX_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyInstancesByPolicyOutput$MaxItems",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyInstancesByPolicyOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_items",
     "MaxItems",
 ,
 );
 static LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_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 LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCES,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_HOSTED_ZONE_ID_MARKER,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_NAME_MARKER,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_TYPE_MARKER,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_IS_TRUNCATED,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_MAX_ITEMS,
         &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListTrafficPolicyInstancesByPolicyOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_SCHEMA;
-139
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListTrafficPolicyInstancesByPolicyOutput {
     #[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> {
-146
+        {
             let val = &self.traffic_policy_instances;
-148
             ser.write_list(
                 &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TrafficPolicyInstance::SCHEMA, item)?;
-154
+                    }
                     Ok(())
                 },
             )?;
-158
+        }
         if let Some(ref val) = self.hosted_zone_id_marker {
             ser.write_string(&LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_HOSTED_ZONE_ID_MARKER, val)?;
-161
+        }
         if let Some(ref val) = self.traffic_policy_instance_name_marker {
             ser.write_string(&LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_NAME_MARKER, val)?;
-164
+        }
         if let Some(ref val) = self.traffic_policy_instance_type_marker {
             ser.write_string(
                 &LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_TRAFFIC_POLICY_INSTANCE_TYPE_MARKER,
                 val.as_str(),
             )?;
-170
+        }
-171
+        {
             let val = &self.is_truncated;
             ser.write_boolean(&LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_IS_TRUNCATED, *val)?;
-174
+        }
-175
+        {
             let val = &self.max_items;
             ser.write_integer(&LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_MEMBER_MAX_ITEMS, *val)?;
-178
+        }
         Ok(())
-180
+    }
-181
+}
 impl ListTrafficPolicyInstancesByPolicyOutput {
     /// 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(&LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.traffic_policy_instances = 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::TrafficPolicyInstance::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TrafficPolicyInstance::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.hosted_zone_id_marker = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.traffic_policy_instance_name_marker = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.traffic_policy_instance_type_marker = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(4) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(5) => {
                     builder.max_items = Some(deser.read_integer(member)?);
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.traffic_policy_instances = builder.traffic_policy_instances.or(Some(Vec::new()));
         builder.is_truncated = builder.is_truncated.or(Some(false));
         builder.max_items = builder.max_items.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl ListTrafficPolicyInstancesByPolicyOutput {
     /// 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(&LISTTRAFFICPOLICYINSTANCESBYPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.traffic_policy_instances = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TrafficPolicyInstance::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-271
+                }
                 Some(1) => {
                     builder.hosted_zone_id_marker = Some(deser.read_string(member)?);
-274
+                }
                 Some(2) => {
                     builder.traffic_policy_instance_name_marker = Some(deser.read_string(member)?);
-277
+                }
                 Some(3) => {
                     builder.traffic_policy_instance_type_marker = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));

↧ Expand context

-280
+                }
                 Some(4) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-283
+                }
                 Some(5) => {
                     builder.max_items = Some(deser.read_integer(member)?);
-286
+                }
                 _ => {}
-288
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-294
+    }
-295
+}
 impl ::aws_types::request_id::RequestId for ListTrafficPolicyInstancesByPolicyOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-299
+    }

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_traffic_policy_versions.rs

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

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

@@ -124,130 +186,193 @@

↥ 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("ListTrafficPolicyVersions")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListTrafficPolicyVersionsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsError,
             >::new());
-152
         ::std::borrow::Cow::Owned(rcb)
-154
+    }
-155
+}
-156
 #[derive(Debug)]
 struct ListTrafficPolicyVersionsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListTrafficPolicyVersionsResponseDeserializer {
     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_list_traffic_policy_versions::de_list_traffic_policy_versions_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_list_traffic_policy_versions::de_list_traffic_policy_versions_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-177
+    }
-178
+}
 #[derive(Debug)]
 struct ListTrafficPolicyVersionsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListTrafficPolicyVersionsRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_traffic_policy_versions/_list_traffic_policy_versions_input.rs

@@ -12,12 +162,179 @@

↥ Expand context

     /// <p>The maximum number of traffic policy versions that you want Amazon Route 53 to include in the response body for this request. If the specified traffic policy has more than <code>MaxItems</code> versions, the value of <code>IsTruncated</code> in the response is <code>true</code>, and the value of the <code>TrafficPolicyVersionMarker</code> element is the ID of the first version that Route 53 will return if you submit another request.</p>
     pub max_items: ::std::option::Option<i32>,
-14
+}
 impl ListTrafficPolicyVersionsInput {
     /// <p>Specify the value of <code>Id</code> of the traffic policy for which you want to list all versions.</p>
     pub fn id(&self) -> ::std::option::Option<&str> {
         self.id.as_deref()
-19
+    }
     /// <p>For your first request to <code>ListTrafficPolicyVersions</code>, don't include the <code>TrafficPolicyVersionMarker</code> parameter.</p>
     /// <p>If you have more traffic policy versions than the value of <code>MaxItems</code>, <code>ListTrafficPolicyVersions</code> returns only the first group of <code>MaxItems</code> versions. To get more traffic policy versions, submit another <code>ListTrafficPolicyVersions</code> request. For the value of <code>TrafficPolicyVersionMarker</code>, specify the value of <code>TrafficPolicyVersionMarker</code> in the previous response.</p>
     pub fn traffic_policy_version_marker(&self) -> ::std::option::Option<&str> {
         self.traffic_policy_version_marker.as_deref()
-24
+    }
     /// <p>The maximum number of traffic policy versions that you want Amazon Route 53 to include in the response body for this request. If the specified traffic policy has more than <code>MaxItems</code> versions, the value of <code>IsTruncated</code> in the response is <code>true</code>, and the value of the <code>TrafficPolicyVersionMarker</code> element is the ID of the first version that Route 53 will return if you submit another request.</p>
     pub fn max_items(&self) -> ::std::option::Option<i32> {
         self.max_items
-28
+    }
-29
+}
 static LISTTRAFFICPOLICYVERSIONSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsInput",

     "com.amazonaws.route53.synthetic",
     "ListTrafficPolicyVersionsInput",
 );
 static LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsInput$Id",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyVersionsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "id",
     "Id",
 ,
-44
+)
 .with_http_label();
 static LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_TRAFFIC_POLICY_VERSION_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsInput$TrafficPolicyVersionMarker",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyVersionsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "traffic_policy_version_marker",
     "TrafficPolicyVersionMarker",
 ,
-55
+)
 .with_http_query("trafficpolicyversion");
 static LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_MAX_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsInput$MaxItems",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyVersionsInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_items",
     "MaxItems",
 ,
-66
+)
 .with_http_query("maxitems");
 static LISTTRAFFICPOLICYVERSIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTTRAFFICPOLICYVERSIONSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_ID,
         &LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_TRAFFIC_POLICY_VERSION_MARKER,
         &LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_MAX_ITEMS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/2013-04-01/trafficpolicies/{Id}/versions",
     None,
 ));
 impl ListTrafficPolicyVersionsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTTRAFFICPOLICYVERSIONSINPUT_SCHEMA;
-85
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListTrafficPolicyVersionsInput {
     #[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.id {
             ser.write_string(&LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_ID, val)?;
-94
+        }
         if let Some(ref val) = self.traffic_policy_version_marker {
             ser.write_string(&LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_TRAFFIC_POLICY_VERSION_MARKER, val)?;
-97
+        }
         if let Some(ref val) = self.max_items {
             ser.write_integer(&LISTTRAFFICPOLICYVERSIONSINPUT_MEMBER_MAX_ITEMS, *val)?;
-100
+        }
         Ok(())
-102
+    }
-103
+}
 impl ListTrafficPolicyVersionsInput {
     /// 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(&LISTTRAFFICPOLICYVERSIONSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTTRAFFICPOLICYVERSIONSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.id = Some(deser.read_string(member)?);
-122
+                }
                 Some(1) => {
                     builder.traffic_policy_version_marker = Some(deser.read_string(member)?);
-125
+                }
                 Some(2) => {
                     builder.max_items = Some(deser.read_integer(member)?);
-128
+                }
                 _ => {}
-130
+            }
             Ok(())
         })?;
         builder.id = builder.id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-137
+    }
-138
+}
 impl ListTrafficPolicyVersionsInput {
     /// 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 ListTrafficPolicyVersionsInput {
     /// Creates a new builder-style object to manufacture [`ListTrafficPolicyVersionsInput`](crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsInput).
     pub fn builder() -> crate::operation::list_traffic_policy_versions::builders::ListTrafficPolicyVersionsInputBuilder {
         crate::operation::list_traffic_policy_versions::builders::ListTrafficPolicyVersionsInputBuilder::default()
-154
+    }
-155
+}
-156
 /// A builder for [`ListTrafficPolicyVersionsInput`](crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListTrafficPolicyVersionsInputBuilder {
     pub(crate) id: ::std::option::Option<::std::string::String>,
     pub(crate) traffic_policy_version_marker: ::std::option::Option<::std::string::String>,
     pub(crate) max_items: ::std::option::Option<i32>,
-164
+}
 impl ListTrafficPolicyVersionsInputBuilder {
     /// <p>Specify the value of <code>Id</code> of the traffic policy for which you want to list all versions.</p>
     /// This field is required.
     pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.id = ::std::option::Option::Some(input.into());
         self
-171
+    }
     /// <p>Specify the value of <code>Id</code> of the traffic policy for which you want to list all versions.</p>
     pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.id = input;
         self
-176
+    }
     /// <p>Specify the value of <code>Id</code> of the traffic policy for which you want to list all versions.</p>
     pub fn get_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.id

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_traffic_policy_versions/_list_traffic_policy_versions_output.rs

@@ -21,21 +188,252 @@

↥ Expand context

         use std::ops::Deref;
         self.traffic_policies.deref()
-23
+    }
     /// <p>A flag that indicates whether there are more traffic policies to be listed. If the response was truncated, you can get the next group of traffic policies by submitting another <code>ListTrafficPolicyVersions</code> request and specifying the value of <code>NextMarker</code> in the <code>marker</code> parameter.</p>
     pub fn is_truncated(&self) -> bool {
         self.is_truncated
-27
+    }
     /// <p>If <code>IsTruncated</code> is <code>true</code>, the value of <code>TrafficPolicyVersionMarker</code> identifies the first traffic policy that Amazon Route 53 will return if you submit another request. Call <code>ListTrafficPolicyVersions</code> again and specify the value of <code>TrafficPolicyVersionMarker</code> in the <code>TrafficPolicyVersionMarker</code> request parameter.</p>
     /// <p>This element is present only if <code>IsTruncated</code> is <code>true</code>.</p>
     pub fn traffic_policy_version_marker(&self) -> &str {
         use std::ops::Deref;
         self.traffic_policy_version_marker.deref()
-33
+    }
     /// <p>The value that you specified for the <code>maxitems</code> parameter in the <code>ListTrafficPolicyVersions</code> request that produced the current response.</p>
     pub fn max_items(&self) -> i32 {
         self.max_items
-37
+    }
-38
+}
 static LISTTRAFFICPOLICYVERSIONSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsOutput",

     "com.amazonaws.route53.synthetic",
     "ListTrafficPolicyVersionsOutput",
 );
 static LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_TRAFFIC_POLICIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsOutput$TrafficPolicies",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyVersionsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "traffic_policies",
     "TrafficPolicies",
 ,
 );
 static LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsOutput$IsTruncated",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyVersionsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "is_truncated",
     "IsTruncated",
 ,
 );
 static LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_TRAFFIC_POLICY_VERSION_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsOutput$TrafficPolicyVersionMarker",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyVersionsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "traffic_policy_version_marker",
     "TrafficPolicyVersionMarker",
 ,
 );
 static LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_MAX_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListTrafficPolicyVersionsOutput$MaxItems",
         "com.amazonaws.route53.synthetic",
         "ListTrafficPolicyVersionsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_items",
     "MaxItems",
 ,
 );
 static LISTTRAFFICPOLICYVERSIONSOUTPUT_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 LISTTRAFFICPOLICYVERSIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTTRAFFICPOLICYVERSIONSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_TRAFFIC_POLICIES,
         &LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_IS_TRUNCATED,
         &LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_TRAFFIC_POLICY_VERSION_MARKER,
         &LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_MAX_ITEMS,
         &LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListTrafficPolicyVersionsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTTRAFFICPOLICYVERSIONSOUTPUT_SCHEMA;
-105
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListTrafficPolicyVersionsOutput {
     #[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> {
-112
+        {
             let val = &self.traffic_policies;
-114
             ser.write_list(
                 &LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_TRAFFIC_POLICIES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::TrafficPolicy::SCHEMA, item)?;
-120
+                    }
                     Ok(())
                 },
             )?;
-124
+        }
-125
+        {
             let val = &self.is_truncated;
             ser.write_boolean(&LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_IS_TRUNCATED, *val)?;
-128
+        }
-129
+        {
             let val = &self.traffic_policy_version_marker;
             ser.write_string(&LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_TRAFFIC_POLICY_VERSION_MARKER, val)?;
-132
+        }
-133
+        {
             let val = &self.max_items;
             ser.write_integer(&LISTTRAFFICPOLICYVERSIONSOUTPUT_MEMBER_MAX_ITEMS, *val)?;
-136
+        }
         Ok(())
-138
+    }
-139
+}
 impl ListTrafficPolicyVersionsOutput {
     /// 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(&LISTTRAFFICPOLICYVERSIONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.traffic_policies = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TrafficPolicy::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(2) => {
                     builder.traffic_policy_version_marker = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.max_items = Some(deser.read_integer(member)?);
-+
+                }
                 Some(4) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.traffic_policies = builder.traffic_policies.or(Some(Vec::new()));
         builder.is_truncated = builder.is_truncated.or(Some(false));
         builder.traffic_policy_version_marker = builder.traffic_policy_version_marker.or(Some(String::new()));
         builder.max_items = builder.max_items.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl ListTrafficPolicyVersionsOutput {
     /// 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(&LISTTRAFFICPOLICYVERSIONSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTTRAFFICPOLICYVERSIONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.traffic_policies = 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::TrafficPolicy::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::TrafficPolicy::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-224
+                }
                 Some(1) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-227
+                }
                 Some(2) => {
                     builder.traffic_policy_version_marker = Some(deser.read_string(member)?);
-230
+                }
                 Some(3) => {
                     builder.max_items = Some(deser.read_integer(member)?);

↧ Expand context

-233
+                }
                 _ => {}
-235
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-241
+    }
-242
+}
 impl ::aws_types::request_id::RequestId for ListTrafficPolicyVersionsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-246
+    }
-247
+}
 impl ListTrafficPolicyVersionsOutput {
     /// Creates a new builder-style object to manufacture [`ListTrafficPolicyVersionsOutput`](crate::operation::list_traffic_policy_versions::ListTrafficPolicyVersionsOutput).
     pub fn builder() -> crate::operation::list_traffic_policy_versions::builders::ListTrafficPolicyVersionsOutputBuilder {
         crate::operation::list_traffic_policy_versions::builders::ListTrafficPolicyVersionsOutputBuilder::default()
-252
+    }

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_vpc_association_authorizations.rs

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

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

@@ -127,133 +189,196 @@

↥ Expand context

-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("ListVPCAssociationAuthorizations")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListVPCAssociationAuthorizationsEndpointParamsInterceptor)
             .with_interceptor(crate::route53_resource_id_preprocessor::Route53ResourceIdInterceptor::new(
                 |input: &mut crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsInput| &mut input.hosted_zone_id,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_vpc_association_authorizations::ListVPCAssociationAuthorizationsError,
             >::new());
-155
         ::std::borrow::Cow::Owned(rcb)
-157
+    }
-158
+}
-159
 #[derive(Debug)]
 struct ListVPCAssociationAuthorizationsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListVPCAssociationAuthorizationsResponseDeserializer {
     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_list_vpc_association_authorizations::de_list_vpc_association_authorizations_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_list_vpc_association_authorizations::de_list_vpc_association_authorizations_http_response(
                 status, headers, body,
-179
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-182
+    }
-183
+}
 #[derive(Debug)]
 struct ListVPCAssociationAuthorizationsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListVPCAssociationAuthorizationsRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_vpc_association_authorizations/_list_vpc_association_authorizations_input.rs

@@ -10,10 +160,177 @@

↥ Expand context

     pub next_token: ::std::option::Option<::std::string::String>,
     /// <p><i>Optional</i>: An integer that specifies the maximum number of VPCs that you want Amazon Route 53 to return. If you don't specify a value for <code>MaxResults</code>, Route 53 returns up to 50 VPCs per page.</p>
     pub max_results: ::std::option::Option<i32>,
-13
+}
 impl ListVpcAssociationAuthorizationsInput {
     /// <p>The ID of the hosted zone for which you want a list of VPCs that can be associated with the hosted zone.</p>
     pub fn hosted_zone_id(&self) -> ::std::option::Option<&str> {
         self.hosted_zone_id.as_deref()
-18
+    }
     /// <p><i>Optional</i>: If a response includes a <code>NextToken</code> element, there are more VPCs that can be associated with the specified hosted zone. To get the next page of results, submit another request, and include the value of <code>NextToken</code> from the response in the <code>nexttoken</code> parameter in another <code>ListVPCAssociationAuthorizations</code> request.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-22
+    }
     /// <p><i>Optional</i>: An integer that specifies the maximum number of VPCs that you want Amazon Route 53 to return. If you don't specify a value for <code>MaxResults</code>, Route 53 returns up to 50 VPCs per page.</p>
     pub fn max_results(&self) -> ::std::option::Option<i32> {
         self.max_results
-26
+    }
-27
+}
 static LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsInput",

     "com.amazonaws.route53.synthetic",
     "ListVPCAssociationAuthorizationsInput",
 );
 static LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_HOSTED_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsInput$HostedZoneId",
         "com.amazonaws.route53.synthetic",
         "ListVPCAssociationAuthorizationsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hosted_zone_id",
     "HostedZoneId",
 ,
-42
+)
 .with_http_label();
 static LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsInput$NextToken",
         "com.amazonaws.route53.synthetic",
         "ListVPCAssociationAuthorizationsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
-53
+)
 .with_http_query("nexttoken");
 static LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsInput$MaxResults",
         "com.amazonaws.route53.synthetic",
         "ListVPCAssociationAuthorizationsInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_results",
     "MaxResults",
 ,
-64
+)
 .with_http_query("maxresults");
 static LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_HOSTED_ZONE_ID,
         &LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_NEXT_TOKEN,
         &LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_MAX_RESULTS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation",
     None,
 ));
 impl ListVpcAssociationAuthorizationsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_SCHEMA;
-83
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListVpcAssociationAuthorizationsInput {
     #[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.hosted_zone_id {
             ser.write_string(&LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_HOSTED_ZONE_ID, val)?;
-92
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_NEXT_TOKEN, val)?;
-95
+        }
         if let Some(ref val) = self.max_results {
             ser.write_integer(&LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_MEMBER_MAX_RESULTS, *val)?;
-98
+        }
         Ok(())
-100
+    }
-101
+}
 impl ListVpcAssociationAuthorizationsInput {
     /// 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(&LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTVPCASSOCIATIONAUTHORIZATIONSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hosted_zone_id = Some(deser.read_string(member)?);
-120
+                }
                 Some(1) => {
                     builder.next_token = Some(deser.read_string(member)?);
-123
+                }
                 Some(2) => {
                     builder.max_results = Some(deser.read_integer(member)?);
-126
+                }
                 _ => {}
-128
+            }
             Ok(())
         })?;
         builder.hosted_zone_id = builder.hosted_zone_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-135
+    }
-136
+}
 impl ListVpcAssociationAuthorizationsInput {
     /// 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 ListVpcAssociationAuthorizationsInput {
     /// Creates a new builder-style object to manufacture [`ListVpcAssociationAuthorizationsInput`](crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsInput).
     pub fn builder() -> crate::operation::list_vpc_association_authorizations::builders::ListVpcAssociationAuthorizationsInputBuilder {
         crate::operation::list_vpc_association_authorizations::builders::ListVpcAssociationAuthorizationsInputBuilder::default()
-152
+    }
-153
+}
-154
 /// A builder for [`ListVpcAssociationAuthorizationsInput`](crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListVpcAssociationAuthorizationsInputBuilder {
     pub(crate) hosted_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) max_results: ::std::option::Option<i32>,
-162
+}
 impl ListVpcAssociationAuthorizationsInputBuilder {
     /// <p>The ID of the hosted zone for which you want a list of VPCs that can be associated with the hosted zone.</p>
     /// This field is required.
     pub fn hosted_zone_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.hosted_zone_id = ::std::option::Option::Some(input.into());
         self
-169
+    }
     /// <p>The ID of the hosted zone for which you want a list of VPCs that can be associated with the hosted zone.</p>
     pub fn set_hosted_zone_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.hosted_zone_id = input;
         self
-174
+    }
     /// <p>The ID of the hosted zone for which you want a list of VPCs that can be associated with the hosted zone.</p>
     pub fn get_hosted_zone_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.hosted_zone_id

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/list_vpc_association_authorizations/_list_vpc_association_authorizations_output.rs

@@ -13,13 +170,229 @@

↥ Expand context

     _request_id: Option<String>,
-14
+}
 impl ListVpcAssociationAuthorizationsOutput {
     /// <p>The ID of the hosted zone that you can associate the listed VPCs with.</p>
     pub fn hosted_zone_id(&self) -> &str {
         use std::ops::Deref;
         self.hosted_zone_id.deref()
-20
+    }
     /// <p>When the response includes a <code>NextToken</code> element, there are more VPCs that can be associated with the specified hosted zone. To get the next page of VPCs, submit another <code>ListVPCAssociationAuthorizations</code> request, and include the value of the <code>NextToken</code> element from the response in the <code>nexttoken</code> request parameter.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-24
+    }
     /// <p>The list of VPCs that are authorized to be associated with the specified hosted zone.</p>
     pub fn vpcs(&self) -> &[crate::types::Vpc] {
         use std::ops::Deref;
         self.vpcs.deref()
-29
+    }
-30
+}
 static LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsOutput",

     "com.amazonaws.route53.synthetic",
     "ListVPCAssociationAuthorizationsOutput",
 );
 static LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_HOSTED_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsOutput$HostedZoneId",
         "com.amazonaws.route53.synthetic",
         "ListVPCAssociationAuthorizationsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hosted_zone_id",
     "HostedZoneId",
 ,
 );
 static LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsOutput$NextToken",
         "com.amazonaws.route53.synthetic",
         "ListVPCAssociationAuthorizationsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
 );
 static LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_VPCS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#ListVPCAssociationAuthorizationsOutput$VPCs",
         "com.amazonaws.route53.synthetic",
         "ListVPCAssociationAuthorizationsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "vpcs",
     "VPCs",
 ,
 );
 static LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_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 LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_HOSTED_ZONE_ID,
         &LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_NEXT_TOKEN,
         &LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_VPCS,
         &LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListVpcAssociationAuthorizationsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_SCHEMA;
-86
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListVpcAssociationAuthorizationsOutput {
     #[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> {
-93
+        {
             let val = &self.hosted_zone_id;
             ser.write_string(&LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_HOSTED_ZONE_ID, val)?;
-96
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
-99
+        }
-100
+        {
             let val = &self.vpcs;
-102
             ser.write_list(
                 &LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_MEMBER_VPCS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Vpc::SCHEMA, item)?;
-108
+                    }
                     Ok(())
                 },
             )?;
-112
+        }
         Ok(())
-114
+    }
-115
+}
 impl ListVpcAssociationAuthorizationsOutput {
     /// 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(&LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hosted_zone_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.next_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.vpcs = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Vpc::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.hosted_zone_id = builder.hosted_zone_id.or(Some(String::new()));
         builder.vpcs = builder.vpcs.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl ListVpcAssociationAuthorizationsOutput {
     /// 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(&LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTVPCASSOCIATIONAUTHORIZATIONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hosted_zone_id = Some(deser.read_string(member)?);
-188
+                }
                 Some(1) => {
                     builder.next_token = Some(deser.read_string(member)?);
-191
+                }
                 Some(2) => {
                     builder.vpcs = 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::Vpc::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Vpc::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-201
+                }
                 _ => {}
-203
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-209
+    }

↧ Expand context

-210
+}
 impl ::aws_types::request_id::RequestId for ListVpcAssociationAuthorizationsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-214
+    }
-215
+}
 impl ListVpcAssociationAuthorizationsOutput {
     /// Creates a new builder-style object to manufacture [`ListVpcAssociationAuthorizationsOutput`](crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsOutput).
     pub fn builder() -> crate::operation::list_vpc_association_authorizations::builders::ListVpcAssociationAuthorizationsOutputBuilder {
         crate::operation::list_vpc_association_authorizations::builders::ListVpcAssociationAuthorizationsOutputBuilder::default()
-220
+    }
-221
+}
-222
 /// A builder for [`ListVpcAssociationAuthorizationsOutput`](crate::operation::list_vpc_association_authorizations::ListVpcAssociationAuthorizationsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListVpcAssociationAuthorizationsOutputBuilder {
     pub(crate) hosted_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) vpcs: ::std::option::Option<::std::vec::Vec<crate::types::Vpc>>,

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/test_dns_answer.rs

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

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

↧ Expand context

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

@@ -115,119 +177,182 @@

↥ Expand context

         });
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     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("TestDNSAnswer")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(TestDNSAnswerEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::test_dns_answer::TestDNSAnswerError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::test_dns_answer::TestDNSAnswerError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::test_dns_answer::TestDNSAnswerError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct TestDNSAnswerResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for TestDNSAnswerResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_test_dns_answer::de_test_dns_answer_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_test_dns_answer::de_test_dns_answer_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}
 #[derive(Debug)]
 struct TestDNSAnswerRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for TestDNSAnswerRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::test_dns_answer::TestDnsAnswerInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/test_dns_answer/_test_dns_answer_input.rs

@@ -42,42 +246,260 @@

↥ Expand context

         self.resolver_ip.as_deref()
-43
+    }
     /// <p>If the resolver that you specified for resolverip supports EDNS0, specify the IPv4 or IPv6 address of a client in the applicable location, for example, <code>192.0.2.44</code> or <code>2001:db8:85a3::8a2e:370:7334</code>.</p>
     pub fn edns0_client_subnet_ip(&self) -> ::std::option::Option<&str> {
         self.edns0_client_subnet_ip.as_deref()
-47
+    }
     /// <p>If you specify an IP address for <code>edns0clientsubnetip</code>, you can optionally specify the number of bits of the IP address that you want the checking tool to include in the DNS query. For example, if you specify <code>192.0.2.44</code> for <code>edns0clientsubnetip</code> and <code>24</code> for <code>edns0clientsubnetmask</code>, the checking tool will simulate a request from 192.0.2.0/24. The default value is 24 bits for IPv4 addresses and 64 bits for IPv6 addresses.</p>
     /// <p>The range of valid values depends on whether <code>edns0clientsubnetip</code> is an IPv4 or an IPv6 address:</p>
     /// <ul>
     /// <li>
     /// <p><b>IPv4</b>: Specify a value between 0 and 32</p></li>
     /// <li>
     /// <p><b>IPv6</b>: Specify a value between 0 and 128</p></li>
     /// </ul>
     pub fn edns0_client_subnet_mask(&self) -> ::std::option::Option<&str> {
         self.edns0_client_subnet_mask.as_deref()
-58
+    }
-59
+}
 static TESTDNSANSWERINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#TestDNSAnswerInput",

     "com.amazonaws.route53.synthetic",
     "TestDNSAnswerInput",
 );
 static TESTDNSANSWERINPUT_MEMBER_HOSTED_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerInput$HostedZoneId",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "hosted_zone_id",
     "HostedZoneId",
 ,
-74
+)
 .with_http_query("hostedzoneid");
 static TESTDNSANSWERINPUT_MEMBER_RECORD_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerInput$RecordName",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "record_name",
     "RecordName",
 ,
-85
+)
 .with_http_query("recordname");
 static TESTDNSANSWERINPUT_MEMBER_RECORD_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerInput$RecordType",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "record_type",
     "RecordType",
 ,
-96
+)
 .with_http_query("recordtype");
 static TESTDNSANSWERINPUT_MEMBER_RESOLVER_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerInput$ResolverIP",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resolver_ip",
     "ResolverIP",
 ,
-107
+)
 .with_http_query("resolverip");
 static TESTDNSANSWERINPUT_MEMBER_EDNS0_CLIENT_SUBNET_IP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerInput$EDNS0ClientSubnetIP",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "edns0_client_subnet_ip",
     "EDNS0ClientSubnetIP",
 ,
-118
+)
 .with_http_query("edns0clientsubnetip");
 static TESTDNSANSWERINPUT_MEMBER_EDNS0_CLIENT_SUBNET_MASK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerInput$EDNS0ClientSubnetMask",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "edns0_client_subnet_mask",
     "EDNS0ClientSubnetMask",
 ,
-129
+)
 .with_http_query("edns0clientsubnetmask");
 static TESTDNSANSWERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TESTDNSANSWERINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &TESTDNSANSWERINPUT_MEMBER_HOSTED_ZONE_ID,
         &TESTDNSANSWERINPUT_MEMBER_RECORD_NAME,
         &TESTDNSANSWERINPUT_MEMBER_RECORD_TYPE,
         &TESTDNSANSWERINPUT_MEMBER_RESOLVER_IP,
         &TESTDNSANSWERINPUT_MEMBER_EDNS0_CLIENT_SUBNET_IP,
         &TESTDNSANSWERINPUT_MEMBER_EDNS0_CLIENT_SUBNET_MASK,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/2013-04-01/testdnsanswer", None));
 impl TestDnsAnswerInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTDNSANSWERINPUT_SCHEMA;
-147
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestDnsAnswerInput {
     #[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.hosted_zone_id {
             ser.write_string(&TESTDNSANSWERINPUT_MEMBER_HOSTED_ZONE_ID, val)?;
-156
+        }
         if let Some(ref val) = self.record_name {
             ser.write_string(&TESTDNSANSWERINPUT_MEMBER_RECORD_NAME, val)?;
-159
+        }
         if let Some(ref val) = self.record_type {
             ser.write_string(&TESTDNSANSWERINPUT_MEMBER_RECORD_TYPE, val.as_str())?;
-162
+        }
         if let Some(ref val) = self.resolver_ip {
             ser.write_string(&TESTDNSANSWERINPUT_MEMBER_RESOLVER_IP, val)?;
-165
+        }
         if let Some(ref val) = self.edns0_client_subnet_ip {
             ser.write_string(&TESTDNSANSWERINPUT_MEMBER_EDNS0_CLIENT_SUBNET_IP, val)?;
-168
+        }
         if let Some(ref val) = self.edns0_client_subnet_mask {
             ser.write_string(&TESTDNSANSWERINPUT_MEMBER_EDNS0_CLIENT_SUBNET_MASK, val)?;
-171
+        }
         Ok(())
-173
+    }
-174
+}
 impl TestDnsAnswerInput {
     /// 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(&TESTDNSANSWERINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTDNSANSWERINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.hosted_zone_id = Some(deser.read_string(member)?);
-193
+                }
                 Some(1) => {
                     builder.record_name = Some(deser.read_string(member)?);
-196
+                }
                 Some(2) => {
                     builder.record_type = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
-199
+                }
                 Some(3) => {
                     builder.resolver_ip = Some(deser.read_string(member)?);
-202
+                }
                 Some(4) => {
                     builder.edns0_client_subnet_ip = Some(deser.read_string(member)?);
-205
+                }
                 Some(5) => {
                     builder.edns0_client_subnet_mask = Some(deser.read_string(member)?);
-208
+                }
                 _ => {}
-210
+            }
             Ok(())
         })?;
         builder.hosted_zone_id = builder.hosted_zone_id.or(Some(String::new()));
         builder.record_name = builder.record_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-218
+    }
-219
+}
 impl TestDnsAnswerInput {
     /// 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 TestDnsAnswerInput {
     /// Creates a new builder-style object to manufacture [`TestDnsAnswerInput`](crate::operation::test_dns_answer::TestDnsAnswerInput).
     pub fn builder() -> crate::operation::test_dns_answer::builders::TestDnsAnswerInputBuilder {
         crate::operation::test_dns_answer::builders::TestDnsAnswerInputBuilder::default()
-235
+    }
-236
+}
-237
 /// A builder for [`TestDnsAnswerInput`](crate::operation::test_dns_answer::TestDnsAnswerInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct TestDnsAnswerInputBuilder {
     pub(crate) hosted_zone_id: ::std::option::Option<::std::string::String>,
     pub(crate) record_name: ::std::option::Option<::std::string::String>,
     pub(crate) record_type: ::std::option::Option<crate::types::RrType>,
     pub(crate) resolver_ip: ::std::option::Option<::std::string::String>,
     pub(crate) edns0_client_subnet_ip: ::std::option::Option<::std::string::String>,
     pub(crate) edns0_client_subnet_mask: ::std::option::Option<::std::string::String>,
-248
+}
 impl TestDnsAnswerInputBuilder {
     /// <p>The ID of the hosted zone that you want Amazon Route 53 to simulate a query for.</p>
     /// This field is required.
     pub fn hosted_zone_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.hosted_zone_id = ::std::option::Option::Some(input.into());
         self
-255
+    }
     /// <p>The ID of the hosted zone that you want Amazon Route 53 to simulate a query for.</p>
     pub fn set_hosted_zone_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.hosted_zone_id = input;
         self
-260
+    }

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/test_dns_answer/_test_dns_answer_output.rs

@@ -34,34 +241,298 @@

↥ Expand context

         &self.record_type
-35
+    }
     /// <p>A list that contains values that Amazon Route 53 returned for this resource record set.</p>
     pub fn record_data(&self) -> &[::std::string::String] {
         use std::ops::Deref;
         self.record_data.deref()
-40
+    }
     /// <p>A code that indicates whether the request is valid or not. The most common response code is <code>NOERROR</code>, meaning that the request is valid. If the response is not valid, Amazon Route 53 returns a response code that describes the error. For a list of possible response codes, see <a href="http://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6">DNS RCODES</a> on the IANA website.</p>
     pub fn response_code(&self) -> &str {
         use std::ops::Deref;
         self.response_code.deref()
-45
+    }
     /// <p>The protocol that Amazon Route 53 used to respond to the request, either <code>UDP</code> or <code>TCP</code>.</p>
     pub fn protocol(&self) -> &str {
         use std::ops::Deref;
         self.protocol.deref()
-50
+    }
-51
+}
 static TESTDNSANSWEROUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#TestDNSAnswerOutput",

     "com.amazonaws.route53.synthetic",
     "TestDNSAnswerOutput",
 );
 static TESTDNSANSWEROUTPUT_MEMBER_NAMESERVER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerOutput$Nameserver",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "nameserver",
     "Nameserver",
 ,
 );
 static TESTDNSANSWEROUTPUT_MEMBER_RECORD_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerOutput$RecordName",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "record_name",
     "RecordName",
 ,
 );
 static TESTDNSANSWEROUTPUT_MEMBER_RECORD_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerOutput$RecordType",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "record_type",
     "RecordType",
 ,
 );
 static TESTDNSANSWEROUTPUT_MEMBER_RECORD_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerOutput$RecordData",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "record_data",
     "RecordData",
 ,
 );
 static TESTDNSANSWEROUTPUT_MEMBER_RESPONSE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerOutput$ResponseCode",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "response_code",
     "ResponseCode",
 ,
 );
 static TESTDNSANSWEROUTPUT_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#TestDNSAnswerOutput$Protocol",
         "com.amazonaws.route53.synthetic",
         "TestDNSAnswerOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "protocol",
     "Protocol",
 ,
 );
 static TESTDNSANSWEROUTPUT_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 TESTDNSANSWEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     TESTDNSANSWEROUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &TESTDNSANSWEROUTPUT_MEMBER_NAMESERVER,
         &TESTDNSANSWEROUTPUT_MEMBER_RECORD_NAME,
         &TESTDNSANSWEROUTPUT_MEMBER_RECORD_TYPE,
         &TESTDNSANSWEROUTPUT_MEMBER_RECORD_DATA,
         &TESTDNSANSWEROUTPUT_MEMBER_RESPONSE_CODE,
         &TESTDNSANSWEROUTPUT_MEMBER_PROTOCOL,
         &TESTDNSANSWEROUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl TestDnsAnswerOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TESTDNSANSWEROUTPUT_SCHEMA;
-140
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for TestDnsAnswerOutput {
     #[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> {
-147
+        {
             let val = &self.nameserver;
             ser.write_string(&TESTDNSANSWEROUTPUT_MEMBER_NAMESERVER, val)?;
-150
+        }
-151
+        {
             let val = &self.record_name;
             ser.write_string(&TESTDNSANSWEROUTPUT_MEMBER_RECORD_NAME, val)?;
-154
+        }
-155
+        {
             let val = &self.record_type;
             ser.write_string(&TESTDNSANSWEROUTPUT_MEMBER_RECORD_TYPE, val.as_str())?;
-158
+        }
-159
+        {
             let val = &self.record_data;
-161
             ser.write_list(
                 &TESTDNSANSWEROUTPUT_MEMBER_RECORD_DATA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-167
+                    }
                     Ok(())
                 },
             )?;
-171
+        }
-172
+        {
             let val = &self.response_code;
             ser.write_string(&TESTDNSANSWEROUTPUT_MEMBER_RESPONSE_CODE, val)?;
-175
+        }
-176
+        {
             let val = &self.protocol;
             ser.write_string(&TESTDNSANSWEROUTPUT_MEMBER_PROTOCOL, val)?;
-179
+        }
         Ok(())
-181
+    }
-182
+}
 impl TestDnsAnswerOutput {
     /// 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(&TESTDNSANSWEROUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&TESTDNSANSWEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nameserver = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.record_name = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.record_type = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(3) => {
                     builder.record_data = Some(deser.read_string_list(member)?);
-+
+                }
                 Some(4) => {
                     builder.response_code = Some(deser.read_string(member)?);
-+
+                }
                 Some(5) => {
                     builder.protocol = Some(deser.read_string(member)?);
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.nameserver = builder.nameserver.or(Some(String::new()));
         builder.record_name = builder.record_name.or(Some(String::new()));
         builder.record_data = builder.record_data.or(Some(Vec::new()));
         builder.response_code = builder.response_code.or(Some(String::new()));
         builder.protocol = builder.protocol.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl TestDnsAnswerOutput {
     /// 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(&TESTDNSANSWEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.nameserver = Some(deser.read_string(member)?);
-260
+                }
                 Some(1) => {
                     builder.record_name = Some(deser.read_string(member)?);
-263
+                }
                 Some(2) => {
                     builder.record_type = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
-266
+                }
                 Some(3) => {
                     builder.record_data = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.record_data = Some(deser.read_string_list(member)?);
-269
+                }
                 Some(4) => {
                     builder.response_code = Some(deser.read_string(member)?);
-272
+                }
                 Some(5) => {
                     builder.protocol = Some(deser.read_string(member)?);
-275
+                }
                 _ => {}
-277
+            }
             Ok(())

↧ Expand context

         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-283
+    }
-284
+}
 impl ::aws_types::request_id::RequestId for TestDnsAnswerOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-288
+    }
-289
+}
 impl TestDnsAnswerOutput {
     /// Creates a new builder-style object to manufacture [`TestDnsAnswerOutput`](crate::operation::test_dns_answer::TestDnsAnswerOutput).
     pub fn builder() -> crate::operation::test_dns_answer::builders::TestDnsAnswerOutputBuilder {
         crate::operation::test_dns_answer::builders::TestDnsAnswerOutputBuilder::default()
-294
+    }
-295
+}
-296
 /// A builder for [`TestDnsAnswerOutput`](crate::operation::test_dns_answer::TestDnsAnswerOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/update_health_check.rs

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

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

↧ Expand context

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

@@ -118,122 +180,185 @@

↥ 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("UpdateHealthCheck")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateHealthCheckEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_health_check::UpdateHealthCheckError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_health_check::UpdateHealthCheckError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_health_check::UpdateHealthCheckError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct UpdateHealthCheckResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateHealthCheckResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_update_health_check::de_update_health_check_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_update_health_check::de_update_health_check_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-169
+    }
-170
+}
 #[derive(Debug)]
 struct UpdateHealthCheckRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateHealthCheckRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::update_health_check::UpdateHealthCheckInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/update_health_check/_update_health_check_input.rs

@@ -294,294 +540,545 @@

↥ Expand context

-294
+    }
     /// <p>A complex type that contains one <code>ResettableElementName</code> element for each element that you want to reset to the default value. Valid values for <code>ResettableElementName</code> include the following:</p>
     /// <ul>
     /// <li>
     /// <p><code>ChildHealthChecks</code>: Amazon Route 53 resets <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_HealthCheckConfig.html#Route53-Type-HealthCheckConfig-ChildHealthChecks">ChildHealthChecks</a> to null.</p></li>
     /// <li>
     /// <p><code>FullyQualifiedDomainName</code>: Route 53 resets <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_UpdateHealthCheck.html#Route53-UpdateHealthCheck-request-FullyQualifiedDomainName">FullyQualifiedDomainName</a>. to null.</p></li>
     /// <li>
     /// <p><code>Regions</code>: Route 53 resets the <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_HealthCheckConfig.html#Route53-Type-HealthCheckConfig-Regions">Regions</a> list to the default set of regions.</p></li>
     /// <li>
     /// <p><code>ResourcePath</code>: Route 53 resets <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_HealthCheckConfig.html#Route53-Type-HealthCheckConfig-ResourcePath">ResourcePath</a> to null.</p></li>
     /// </ul>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.reset_elements.is_none()`.
     pub fn reset_elements(&self) -> &[crate::types::ResettableElementName] {
         self.reset_elements.as_deref().unwrap_or_default()
-310
+    }
-311
+}
 static UPDATEHEALTHCHECKINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#UpdateHealthCheckInput",

     "com.amazonaws.route53.synthetic",
     "UpdateHealthCheckInput",
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_CHECK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$HealthCheckId",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "health_check_id",
     "HealthCheckId",
 ,
-326
+)
 .with_http_label();
 static UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_CHECK_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$HealthCheckVersion",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "health_check_version",
     "HealthCheckVersion",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$IPAddress",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ip_address",
     "IPAddress",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$Port",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "port",
     "Port",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_RESOURCE_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$ResourcePath",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "resource_path",
     "ResourcePath",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_FULLY_QUALIFIED_DOMAIN_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$FullyQualifiedDomainName",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "fully_qualified_domain_name",
     "FullyQualifiedDomainName",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_SEARCH_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$SearchString",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "search_string",
     "SearchString",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_FAILURE_THRESHOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$FailureThreshold",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "failure_threshold",
     "FailureThreshold",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_INVERTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$Inverted",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "inverted",
     "Inverted",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_DISABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$Disabled",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "disabled",
     "Disabled",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_THRESHOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$HealthThreshold",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "health_threshold",
     "HealthThreshold",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_CHILD_HEALTH_CHECKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$ChildHealthChecks",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "child_health_checks",
     "ChildHealthChecks",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_ENABLE_SNI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$EnableSNI",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "enable_sni",
     "EnableSNI",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_REGIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$Regions",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "regions",
     "Regions",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_ALARM_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$AlarmIdentifier",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "alarm_identifier",
     "AlarmIdentifier",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_INSUFFICIENT_DATA_HEALTH_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$InsufficientDataHealthStatus",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "insufficient_data_health_status",
     "InsufficientDataHealthStatus",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_MEMBER_RESET_ELEMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckInput$ResetElements",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "reset_elements",
     "ResetElements",
 ,
 );
 static UPDATEHEALTHCHECKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATEHEALTHCHECKINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_CHECK_ID,
         &UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_CHECK_VERSION,
         &UPDATEHEALTHCHECKINPUT_MEMBER_IP_ADDRESS,
         &UPDATEHEALTHCHECKINPUT_MEMBER_PORT,
         &UPDATEHEALTHCHECKINPUT_MEMBER_RESOURCE_PATH,
         &UPDATEHEALTHCHECKINPUT_MEMBER_FULLY_QUALIFIED_DOMAIN_NAME,
         &UPDATEHEALTHCHECKINPUT_MEMBER_SEARCH_STRING,
         &UPDATEHEALTHCHECKINPUT_MEMBER_FAILURE_THRESHOLD,
         &UPDATEHEALTHCHECKINPUT_MEMBER_INVERTED,
         &UPDATEHEALTHCHECKINPUT_MEMBER_DISABLED,
         &UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_THRESHOLD,
         &UPDATEHEALTHCHECKINPUT_MEMBER_CHILD_HEALTH_CHECKS,
         &UPDATEHEALTHCHECKINPUT_MEMBER_ENABLE_SNI,
         &UPDATEHEALTHCHECKINPUT_MEMBER_REGIONS,
         &UPDATEHEALTHCHECKINPUT_MEMBER_ALARM_IDENTIFIER,
         &UPDATEHEALTHCHECKINPUT_MEMBER_INSUFFICIENT_DATA_HEALTH_STATUS,
         &UPDATEHEALTHCHECKINPUT_MEMBER_RESET_ELEMENTS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/2013-04-01/healthcheck/{HealthCheckId}",
     None,
 ));
 impl UpdateHealthCheckInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATEHEALTHCHECKINPUT_SCHEMA;
-519
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateHealthCheckInput {
     #[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> {

↧ Expand context

         if let Some(ref val) = self.health_check_id {
             ser.write_string(&UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_CHECK_ID, val)?;
-528
+        }
         if let Some(ref val) = self.health_check_version {
             ser.write_long(&UPDATEHEALTHCHECKINPUT_MEMBER_HEALTH_CHECK_VERSION, *val)?;
-531
+        }
         if let Some(ref val) = self.ip_address {
             ser.write_string(&UPDATEHEALTHCHECKINPUT_MEMBER_IP_ADDRESS, val)?;
-534
+        }
         if let Some(ref val) = self.port {
             ser.write_integer(&UPDATEHEALTHCHECKINPUT_MEMBER_PORT, *val)?;
-537
+        }
         if let Some(ref val) = self.resource_path {
             ser.write_string(&UPDATEHEALTHCHECKINPUT_MEMBER_RESOURCE_PATH, val)?;
-540
+        }
         if let Some(ref val) = self.fully_qualified_domain_name {
             ser.write_string(&UPDATEHEALTHCHECKINPUT_MEMBER_FULLY_QUALIFIED_DOMAIN_NAME, val)?;
-543
+        }
         if let Some(ref val) = self.search_string {
             ser.write_string(&UPDATEHEALTHCHECKINPUT_MEMBER_SEARCH_STRING, val)?;

@@ -571,576 +735,736 @@

↥ Expand context

                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
-579
+                    }
                     Ok(())
                 },
             )?;
-583
+        }
         if let Some(ref val) = self.alarm_identifier {
             ser.write_struct(&UPDATEHEALTHCHECKINPUT_MEMBER_ALARM_IDENTIFIER, val)?;
-586
+        }
         if let Some(ref val) = self.insufficient_data_health_status {
             ser.write_string(&UPDATEHEALTHCHECKINPUT_MEMBER_INSUFFICIENT_DATA_HEALTH_STATUS, val.as_str())?;
-589
+        }
         if let Some(ref val) = self.reset_elements {
             ser.write_list(
                 &UPDATEHEALTHCHECKINPUT_MEMBER_RESET_ELEMENTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;

-596
+                    }
                     Ok(())
                 },
             )?;
-600
+        }
         Ok(())
-602
+    }
-603
+}
 impl UpdateHealthCheckInput {
     /// 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(&UPDATEHEALTHCHECKINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATEHEALTHCHECKINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.health_check_id = Some(deser.read_string(member)?);
-622
+                }
                 Some(1) => {
                     builder.health_check_version = Some(deser.read_long(member)?);
-625
+                }
                 Some(2) => {
                     builder.ip_address = Some(deser.read_string(member)?);
-628
+                }
                 Some(3) => {
                     builder.port = Some(deser.read_integer(member)?);
-631
+                }
                 Some(4) => {
                     builder.resource_path = Some(deser.read_string(member)?);
-634
+                }
                 Some(5) => {
                     builder.fully_qualified_domain_name = Some(deser.read_string(member)?);
-637
+                }
                 Some(6) => {
                     builder.search_string = Some(deser.read_string(member)?);
-640
+                }
                 Some(7) => {
                     builder.failure_threshold = Some(deser.read_integer(member)?);
-643
+                }
                 Some(8) => {
                     builder.inverted = Some(deser.read_boolean(member)?);
-646
+                }
                 Some(9) => {
                     builder.disabled = Some(deser.read_boolean(member)?);
-649
+                }
                 Some(10) => {
                     builder.health_threshold = Some(deser.read_integer(member)?);
-652
+                }
                 Some(11) => {
                     builder.child_health_checks = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.child_health_checks = Some(deser.read_string_list(member)?);
-655
+                }
                 Some(12) => {
                     builder.enable_sni = Some(deser.read_boolean(member)?);
-658
+                }
                 Some(13) => {
                     builder.regions = 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::HealthCheckRegion::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::HealthCheckRegion::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-668
+                }
                 Some(14) => {
                     builder.alarm_identifier = Some(crate::types::AlarmIdentifier::deserialize(deser)?);
-671
+                }
                 Some(15) => {
                     builder.insufficient_data_health_status =
                         Some(crate::types::InsufficientDataHealthStatus::from(deser.read_string(member)?.as_str()));
-675
+                }
                 Some(16) => {
                     builder.reset_elements = 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::ResettableElementName::from(deser.read_string(member)?.as_str()));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ResettableElementName::from(deser.read_string(member)?.as_str()));
                             Ok(())
                         })?;
                         container
                     });
-685
+                }
                 _ => {}
-687
+            }
             Ok(())
         })?;
         builder.health_check_id = builder.health_check_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-694
+    }
-695
+}
 impl UpdateHealthCheckInput {
     /// 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 UpdateHealthCheckInput {
     /// Creates a new builder-style object to manufacture [`UpdateHealthCheckInput`](crate::operation::update_health_check::UpdateHealthCheckInput).
     pub fn builder() -> crate::operation::update_health_check::builders::UpdateHealthCheckInputBuilder {
         crate::operation::update_health_check::builders::UpdateHealthCheckInputBuilder::default()
-711
+    }
-712
+}
-713
 /// A builder for [`UpdateHealthCheckInput`](crate::operation::update_health_check::UpdateHealthCheckInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct UpdateHealthCheckInputBuilder {
     pub(crate) health_check_id: ::std::option::Option<::std::string::String>,
     pub(crate) health_check_version: ::std::option::Option<i64>,
     pub(crate) ip_address: ::std::option::Option<::std::string::String>,
     pub(crate) port: ::std::option::Option<i32>,
     pub(crate) resource_path: ::std::option::Option<::std::string::String>,
     pub(crate) fully_qualified_domain_name: ::std::option::Option<::std::string::String>,
     pub(crate) search_string: ::std::option::Option<::std::string::String>,
     pub(crate) failure_threshold: ::std::option::Option<i32>,
     pub(crate) inverted: ::std::option::Option<bool>,
     pub(crate) disabled: ::std::option::Option<bool>,
     pub(crate) health_threshold: ::std::option::Option<i32>,
     pub(crate) child_health_checks: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) enable_sni: ::std::option::Option<bool>,
     pub(crate) regions: ::std::option::Option<::std::vec::Vec<crate::types::HealthCheckRegion>>,
     pub(crate) alarm_identifier: ::std::option::Option<crate::types::AlarmIdentifier>,
     pub(crate) insufficient_data_health_status: ::std::option::Option<crate::types::InsufficientDataHealthStatus>,
     pub(crate) reset_elements: ::std::option::Option<::std::vec::Vec<crate::types::ResettableElementName>>,
-735
+}
 impl UpdateHealthCheckInputBuilder {

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/update_health_check/_update_health_check_output.rs

@@ -1,1 +97,141 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>A complex type that contains the response to the <code>UpdateHealthCheck</code> request.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct UpdateHealthCheckOutput {
     /// <p>A complex type that contains the response to an <code>UpdateHealthCheck</code> request.</p>
     pub health_check: ::std::option::Option<crate::types::HealthCheck>,
     _request_id: Option<String>,
-10
+}
 impl UpdateHealthCheckOutput {
     /// <p>A complex type that contains the response to an <code>UpdateHealthCheck</code> request.</p>
     pub fn health_check(&self) -> ::std::option::Option<&crate::types::HealthCheck> {
         self.health_check.as_ref()
-15
+    }
-16
+}
 static UPDATEHEALTHCHECKOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.route53.synthetic#UpdateHealthCheckOutput",

     "com.amazonaws.route53.synthetic",
     "UpdateHealthCheckOutput",
 );
 static UPDATEHEALTHCHECKOUTPUT_MEMBER_HEALTH_CHECK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.route53.synthetic#UpdateHealthCheckOutput$HealthCheck",
         "com.amazonaws.route53.synthetic",
         "UpdateHealthCheckOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "health_check",
     "HealthCheck",
 ,
 );
 static UPDATEHEALTHCHECKOUTPUT_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 UPDATEHEALTHCHECKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPDATEHEALTHCHECKOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&UPDATEHEALTHCHECKOUTPUT_MEMBER_HEALTH_CHECK],
     &[&UPDATEHEALTHCHECKOUTPUT_MEMBER_HEALTH_CHECK, &UPDATEHEALTHCHECKOUTPUT_MEMBER__REQUEST_ID],
 );
 impl UpdateHealthCheckOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPDATEHEALTHCHECKOUTPUT_SCHEMA;
-47
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UpdateHealthCheckOutput {
     #[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.health_check {
             ser.write_struct(&UPDATEHEALTHCHECKOUTPUT_MEMBER_HEALTH_CHECK, val)?;
-56
+        }
         Ok(())
-58
+    }
-59
+}
 impl UpdateHealthCheckOutput {
     /// 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(&UPDATEHEALTHCHECKOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPDATEHEALTHCHECKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.health_check = Some(crate::types::HealthCheck::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl UpdateHealthCheckOutput {
     /// 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(&UPDATEHEALTHCHECKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.health_check = Some(crate::types::HealthCheck::deserialize(deser)?);
-115
+                }
                 _ => {}
-117
+            }
             Ok(())
         })?;
         Ok(builder.build())
-121
+    }

↧ Expand context

-122
+}
 impl ::aws_types::request_id::RequestId for UpdateHealthCheckOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-126
+    }
-127
+}
 impl UpdateHealthCheckOutput {
     /// Creates a new builder-style object to manufacture [`UpdateHealthCheckOutput`](crate::operation::update_health_check::UpdateHealthCheckOutput).
     pub fn builder() -> crate::operation::update_health_check::builders::UpdateHealthCheckOutputBuilder {
         crate::operation::update_health_check::builders::UpdateHealthCheckOutputBuilder::default()
-132
+    }
-133
+}
-134
 /// A builder for [`UpdateHealthCheckOutput`](crate::operation::update_health_check::UpdateHealthCheckOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UpdateHealthCheckOutputBuilder {
     pub(crate) health_check: ::std::option::Option<crate::types::HealthCheck>,
     _request_id: Option<String>,
-141
+}

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/update_hosted_zone_comment.rs

@@ -1,1 +40,45 @@

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

↧ Expand context

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

@@ -121,126 +183,189 @@

↥ Expand context

-126
+    }
-127
     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("UpdateHostedZoneComment")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UpdateHostedZoneCommentEndpointParamsInterceptor)
             .with_interceptor(crate::route53_resource_id_preprocessor::Route53ResourceIdInterceptor::new(
                 |input: &mut crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentInput| &mut input.id,
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentError,
             >::new());
-148
         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct UpdateHostedZoneCommentResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateHostedZoneCommentResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_update_hosted_zone_comment::de_update_hosted_zone_comment_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_update_hosted_zone_comment::de_update_hosted_zone_comment_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-173
+    }
-174
+}
 #[derive(Debug)]
 struct UpdateHostedZoneCommentRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateHostedZoneCommentRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::update_hosted_zone_comment::UpdateHostedZoneCommentInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

AWS SDK

Files changed: