AWS SDK

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_service_last_accessed_details_with_entities/_get_service_last_accessed_details_with_entities_output.rs

@@ -37,37 +259,331 @@

     /// <p>An&nbsp;<code>EntityDetailsList</code> object that contains details about when an IAM entity (user or role) used group or policy permissions in an attempt to access the specified Amazon Web Services service.</p>
     pub fn entity_details_list(&self) -> &[crate::types::EntityDetails] {
         use std::ops::Deref;
         self.entity_details_list.deref()
-41
+    }
     /// <p>A flag that indicates whether there are more items to return. If your results were truncated, you can make a subsequent pagination request using the <code>Marker</code> request parameter to retrieve more items. Note that IAM might return fewer than the <code>MaxItems</code> number of results even when there are more results available. We recommend that you check <code>IsTruncated</code> after every call to ensure that you receive all your results.</p>
     pub fn is_truncated(&self) -> bool {
         self.is_truncated
-45
+    }
     /// <p>When <code>IsTruncated</code> is <code>true</code>, this element is present and contains the value to use for the <code>Marker</code> parameter in a subsequent pagination request.</p>
     pub fn marker(&self) -> ::std::option::Option<&str> {
         self.marker.as_deref()
-49
+    }
     /// <p>An object that contains details about the reason the operation failed.</p>
     pub fn error(&self) -> ::std::option::Option<&crate::types::ErrorDetails> {
         self.error.as_ref()
-53
+    }
-54
+}
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput",

     "com.amazonaws.iam.synthetic",
     "GetServiceLastAccessedDetailsWithEntitiesOutput",
 );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput$JobStatus",
         "com.amazonaws.iam.synthetic",
         "GetServiceLastAccessedDetailsWithEntitiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "job_status",
     "JobStatus",
 ,
 );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_CREATION_DATE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput$JobCreationDate",
             "com.amazonaws.iam.synthetic",
             "GetServiceLastAccessedDetailsWithEntitiesOutput",
         ),
         ::aws_smithy_schema::ShapeType::Timestamp,
         "job_creation_date",
         "JobCreationDate",
 ,
     );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_COMPLETION_DATE: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput$JobCompletionDate",
             "com.amazonaws.iam.synthetic",
             "GetServiceLastAccessedDetailsWithEntitiesOutput",
         ),
         ::aws_smithy_schema::ShapeType::Timestamp,
         "job_completion_date",
         "JobCompletionDate",
 ,
     );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_ENTITY_DETAILS_LIST: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_member(
         ::aws_smithy_schema::ShapeId::from_static(
             "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput$EntityDetailsList",
             "com.amazonaws.iam.synthetic",
             "GetServiceLastAccessedDetailsWithEntitiesOutput",
         ),
         ::aws_smithy_schema::ShapeType::List,
         "entity_details_list",
         "EntityDetailsList",
 ,
     );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput$IsTruncated",
         "com.amazonaws.iam.synthetic",
         "GetServiceLastAccessedDetailsWithEntitiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "is_truncated",
     "IsTruncated",
 ,
 );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput$Marker",
         "com.amazonaws.iam.synthetic",
         "GetServiceLastAccessedDetailsWithEntitiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "marker",
     "Marker",
 ,
 );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_ERROR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetServiceLastAccessedDetailsWithEntitiesOutput$Error",
         "com.amazonaws.iam.synthetic",
         "GetServiceLastAccessedDetailsWithEntitiesOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "error",
     "Error",
 ,
 );
 static GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_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 GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_STATUS,
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_CREATION_DATE,
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_COMPLETION_DATE,
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_ENTITY_DETAILS_LIST,
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_IS_TRUNCATED,
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_MARKER,
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_ERROR,
         &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetServiceLastAccessedDetailsWithEntitiesOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_SCHEMA;
-157
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetServiceLastAccessedDetailsWithEntitiesOutput {
     #[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> {
-164
+        {
             let val = &self.job_status;
             ser.write_string(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_STATUS, val.as_str())?;
-167
+        }
-168
+        {
             let val = &self.job_creation_date;
             ser.write_timestamp(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_CREATION_DATE, val)?;
-171
+        }
-172
+        {
             let val = &self.job_completion_date;
             ser.write_timestamp(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_JOB_COMPLETION_DATE, val)?;
-175
+        }
-176
+        {
             let val = &self.entity_details_list;
-178
             ser.write_list(
                 &GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_ENTITY_DETAILS_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::EntityDetails::SCHEMA, item)?;
-184
+                    }
                     Ok(())
                 },
             )?;
-188
+        }
-189
+        {
             let val = &self.is_truncated;
             ser.write_boolean(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_IS_TRUNCATED, *val)?;
-192
+        }
         if let Some(ref val) = self.marker {
             ser.write_string(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_MARKER, val)?;
-195
+        }
         if let Some(ref val) = self.error {
             ser.write_struct(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_MEMBER_ERROR, val)?;
-198
+        }
         Ok(())
-200
+    }
-201
+}
 impl GetServiceLastAccessedDetailsWithEntitiesOutput {
     /// 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(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.job_status = Some(crate::types::JobStatusType::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(1) => {
                     builder.job_creation_date = Some(deser.read_timestamp(member)?);
-+
+                }
                 Some(2) => {
                     builder.job_completion_date = Some(deser.read_timestamp(member)?);
-+
+                }
                 Some(3) => {
                     builder.entity_details_list = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::EntityDetails::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(4) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(5) => {
                     builder.marker = Some(deser.read_string(member)?);
-+
+                }
                 Some(6) => {
                     builder.error = Some(crate::types::ErrorDetails::deserialize(deser)?);
-+
+                }
                 Some(7) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.job_creation_date = builder.job_creation_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         builder.job_completion_date = builder.job_completion_date.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
         builder.entity_details_list = builder.entity_details_list.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl GetServiceLastAccessedDetailsWithEntitiesOutput {
     /// 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(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSERVICELASTACCESSEDDETAILSWITHENTITIESOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.job_status = Some(crate::types::JobStatusType::from(deser.read_string(member)?.as_str()));
-287
+                }
                 Some(1) => {
                     builder.job_creation_date = Some(deser.read_timestamp(member)?);
-290
+                }
                 Some(2) => {
                     builder.job_completion_date = Some(deser.read_timestamp(member)?);
-293
+                }
                 Some(3) => {
                     builder.entity_details_list = 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::EntityDetails::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::EntityDetails::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-303
+                }
                 Some(4) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-306
+                }
                 Some(5) => {
                     builder.marker = Some(deser.read_string(member)?);
-309
+                }
                 Some(6) => {
                     builder.error = Some(crate::types::ErrorDetails::deserialize(deser)?);

↧ Expand context

-312
+                }
                 _ => {}
-314
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-320
+    }
-321
+}
 impl ::aws_types::request_id::RequestId for GetServiceLastAccessedDetailsWithEntitiesOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-325
+    }
-326
+}
 impl GetServiceLastAccessedDetailsWithEntitiesOutput {
     /// Creates a new builder-style object to manufacture [`GetServiceLastAccessedDetailsWithEntitiesOutput`](crate::operation::get_service_last_accessed_details_with_entities::GetServiceLastAccessedDetailsWithEntitiesOutput).
     pub fn builder(
     ) -> crate::operation::get_service_last_accessed_details_with_entities::builders::GetServiceLastAccessedDetailsWithEntitiesOutputBuilder {
         crate::operation::get_service_last_accessed_details_with_entities::builders::GetServiceLastAccessedDetailsWithEntitiesOutputBuilder::default()

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_service_linked_role_deletion_status.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `GetServiceLinkedRoleDeletionStatus`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetServiceLinkedRoleDeletionStatus;
 impl GetServiceLinkedRoleDeletionStatus {
     /// Creates a new `GetServiceLinkedRoleDeletionStatus`
     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::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusInput,
     ) -> ::std::result::Result<
         crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusError,
             ::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::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusError>()
                     .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::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusOutput>()
                 .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("GetServiceLinkedRoleDeletionStatus")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetServiceLinkedRoleDeletionStatusEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

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

↧ Expand context

-174
+            )
         } else {
             crate::protocol_serde::shape_get_service_linked_role_deletion_status::de_get_service_linked_role_deletion_status_http_response(
                 status, headers, body,
-178
+            )
         };
         crate::protocol_serde::type_erase_result(parse_result)
-181
+    }
-182
+}
 #[derive(Debug)]
 struct GetServiceLinkedRoleDeletionStatusRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetServiceLinkedRoleDeletionStatusRequestSerializer {
     #[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::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusInput>()

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_service_linked_role_deletion_status/_get_service_linked_role_deletion_status_input.rs

@@ -9,9 +120,132 @@

↥ Expand context

     /// /
     /// <task-uuid></task-uuid>
     /// </role-name>
     /// </service-principal-name></code>.</p>
     pub deletion_task_id: ::std::option::Option<::std::string::String>,
-14
+}
 impl GetServiceLinkedRoleDeletionStatusInput {
     /// <p>The deletion task identifier. This identifier is returned by the <a href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServiceLinkedRole.html">DeleteServiceLinkedRole</a> operation in the format <code>task/aws-service-role/<service-principal-name>
     /// /
     /// <role-name>
     /// /
     /// <task-uuid></task-uuid>
     /// </role-name>
     /// </service-principal-name></code>.</p>
     pub fn deletion_task_id(&self) -> ::std::option::Option<&str> {
         self.deletion_task_id.as_deref()
-25
+    }
-26
+}
 static GETSERVICELINKEDROLEDELETIONSTATUSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetServiceLinkedRoleDeletionStatusInput",

     "com.amazonaws.iam.synthetic",
     "GetServiceLinkedRoleDeletionStatusInput",
 );
 static GETSERVICELINKEDROLEDELETIONSTATUSINPUT_MEMBER_DELETION_TASK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetServiceLinkedRoleDeletionStatusInput$DeletionTaskId",
         "com.amazonaws.iam.synthetic",
         "GetServiceLinkedRoleDeletionStatusInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "deletion_task_id",
     "DeletionTaskId",
 ,
 );
 static GETSERVICELINKEDROLEDELETIONSTATUSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSERVICELINKEDROLEDELETIONSTATUSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETSERVICELINKEDROLEDELETIONSTATUSINPUT_MEMBER_DELETION_TASK_ID],
 );
 impl GetServiceLinkedRoleDeletionStatusInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSERVICELINKEDROLEDELETIONSTATUSINPUT_SCHEMA;
-50
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetServiceLinkedRoleDeletionStatusInput {
     #[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.deletion_task_id {
             ser.write_string(&GETSERVICELINKEDROLEDELETIONSTATUSINPUT_MEMBER_DELETION_TASK_ID, val)?;
-59
+        }
         Ok(())
-61
+    }
-62
+}
 impl GetServiceLinkedRoleDeletionStatusInput {
     /// 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(&GETSERVICELINKEDROLEDELETIONSTATUSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSERVICELINKEDROLEDELETIONSTATUSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.deletion_task_id = Some(deser.read_string(member)?);
-81
+                }
                 _ => {}
-83
+            }
             Ok(())
         })?;
         builder.deletion_task_id = builder.deletion_task_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-90
+    }
-91
+}
 impl GetServiceLinkedRoleDeletionStatusInput {
     /// 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 GetServiceLinkedRoleDeletionStatusInput {
     /// Creates a new builder-style object to manufacture [`GetServiceLinkedRoleDeletionStatusInput`](crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusInput).
     pub fn builder() -> crate::operation::get_service_linked_role_deletion_status::builders::GetServiceLinkedRoleDeletionStatusInputBuilder {
         crate::operation::get_service_linked_role_deletion_status::builders::GetServiceLinkedRoleDeletionStatusInputBuilder::default()
-107
+    }
-108
+}
-109
 /// A builder for [`GetServiceLinkedRoleDeletionStatusInput`](crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetServiceLinkedRoleDeletionStatusInputBuilder {
     pub(crate) deletion_task_id: ::std::option::Option<::std::string::String>,
-115
+}
 impl GetServiceLinkedRoleDeletionStatusInputBuilder {
     /// <p>The deletion task identifier. This identifier is returned by the <a href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServiceLinkedRole.html">DeleteServiceLinkedRole</a> operation in the format <code>task/aws-service-role/<service-principal-name>
     /// /
     /// <role-name>
     /// /
     /// <task-uuid></task-uuid>
     /// </role-name>
     /// </service-principal-name></code>.</p>
     /// This field is required.
     pub fn deletion_task_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.deletion_task_id = ::std::option::Option::Some(input.into());
         self
-128
+    }
     /// <p>The deletion task identifier. This identifier is returned by the <a href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_DeleteServiceLinkedRole.html">DeleteServiceLinkedRole</a> operation in the format <code>task/aws-service-role/<service-principal-name>
     /// /
     /// <role-name>
     /// /

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_service_linked_role_deletion_status/_get_service_linked_role_deletion_status_output.rs

@@ -4,4 +119,169 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetServiceLinkedRoleDeletionStatusOutput {
     /// <p>The status of the deletion.</p>
     pub status: crate::types::DeletionTaskStatusType,
     /// <p>An object that contains details about the reason the deletion failed.</p>
     pub reason: ::std::option::Option<crate::types::DeletionTaskFailureReasonType>,
     _request_id: Option<String>,
-11
+}
 impl GetServiceLinkedRoleDeletionStatusOutput {
     /// <p>The status of the deletion.</p>
     pub fn status(&self) -> &crate::types::DeletionTaskStatusType {
         &self.status
-16
+    }
     /// <p>An object that contains details about the reason the deletion failed.</p>
     pub fn reason(&self) -> ::std::option::Option<&crate::types::DeletionTaskFailureReasonType> {
         self.reason.as_ref()
-20
+    }
-21
+}
 static GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetServiceLinkedRoleDeletionStatusOutput",

     "com.amazonaws.iam.synthetic",
     "GetServiceLinkedRoleDeletionStatusOutput",
 );
 static GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetServiceLinkedRoleDeletionStatusOutput$Status",
         "com.amazonaws.iam.synthetic",
         "GetServiceLinkedRoleDeletionStatusOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "status",
     "Status",
 ,
 );
 static GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_MEMBER_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetServiceLinkedRoleDeletionStatusOutput$Reason",
         "com.amazonaws.iam.synthetic",
         "GetServiceLinkedRoleDeletionStatusOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "reason",
     "Reason",
 ,
 );
 static GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_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 GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_MEMBER_STATUS,
         &GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_MEMBER_REASON,
         &GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetServiceLinkedRoleDeletionStatusOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_SCHEMA;
-66
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetServiceLinkedRoleDeletionStatusOutput {
     #[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> {
-73
+        {
             let val = &self.status;
             ser.write_string(&GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_MEMBER_STATUS, val.as_str())?;
-76
+        }
         if let Some(ref val) = self.reason {
             ser.write_struct(&GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_MEMBER_REASON, val)?;
-79
+        }
         Ok(())
-81
+    }
-82
+}
 impl GetServiceLinkedRoleDeletionStatusOutput {
     /// 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(&GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.status = Some(crate::types::DeletionTaskStatusType::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(1) => {
                     builder.reason = Some(crate::types::DeletionTaskFailureReasonType::deserialize(deser)?);
-+
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl GetServiceLinkedRoleDeletionStatusOutput {
     /// 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(&GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSERVICELINKEDROLEDELETIONSTATUSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.status = Some(crate::types::DeletionTaskStatusType::from(deser.read_string(member)?.as_str()));
-143
+                }
                 Some(1) => {
                     builder.reason = Some(crate::types::DeletionTaskFailureReasonType::deserialize(deser)?);
-146
+                }
                 _ => {}
-148
+            }
             Ok(())

↧ Expand context

         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-154
+    }
-155
+}
 impl ::aws_types::request_id::RequestId for GetServiceLinkedRoleDeletionStatusOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-159
+    }
-160
+}
 impl GetServiceLinkedRoleDeletionStatusOutput {
     /// Creates a new builder-style object to manufacture [`GetServiceLinkedRoleDeletionStatusOutput`](crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusOutput).
     pub fn builder() -> crate::operation::get_service_linked_role_deletion_status::builders::GetServiceLinkedRoleDeletionStatusOutputBuilder {
         crate::operation::get_service_linked_role_deletion_status::builders::GetServiceLinkedRoleDeletionStatusOutputBuilder::default()
-165
+    }
-166
+}
-167
 /// A builder for [`GetServiceLinkedRoleDeletionStatusOutput`](crate::operation::get_service_linked_role_deletion_status::GetServiceLinkedRoleDeletionStatusOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_ssh_public_key.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `GetSSHPublicKey`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetSSHPublicKey;
 impl GetSSHPublicKey {
     /// Creates a new `GetSSHPublicKey`
     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::get_ssh_public_key::GetSshPublicKeyInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_ssh_public_key::GetSshPublicKeyOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_ssh_public_key::GetSshPublicKeyInput,
     ) -> ::std::result::Result<
         crate::operation::get_ssh_public_key::GetSshPublicKeyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_ssh_public_key::GetSSHPublicKeyError,
             ::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::get_ssh_public_key::GetSSHPublicKeyError>()
                     .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::get_ssh_public_key::GetSshPublicKeyOutput>()
                 .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("GetSSHPublicKey")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetSSHPublicKeyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_ssh_public_key::GetSSHPublicKeyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_ssh_public_key::GetSSHPublicKeyError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_ssh_public_key::GetSSHPublicKeyError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct GetSSHPublicKeyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetSSHPublicKeyResponseDeserializer {
     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_get_ssh_public_key::de_get_ssh_public_key_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_get_ssh_public_key::de_get_ssh_public_key_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}
 #[derive(Debug)]
 struct GetSSHPublicKeyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetSSHPublicKeyRequestSerializer {
     #[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::get_ssh_public_key::GetSshPublicKeyInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_ssh_public_key/_get_ssh_public_key_input.rs

@@ -13,13 +160,173 @@

↥ Expand context

     pub encoding: ::std::option::Option<crate::types::EncodingType>,
-14
+}
 impl GetSshPublicKeyInput {
     /// <p>The name of the IAM user associated with the SSH public key.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn user_name(&self) -> ::std::option::Option<&str> {
         self.user_name.as_deref()
-20
+    }
     /// <p>The unique identifier for the SSH public key.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters that can consist of any upper or lowercased letter or digit.</p>
     pub fn ssh_public_key_id(&self) -> ::std::option::Option<&str> {
         self.ssh_public_key_id.as_deref()
-25
+    }
     /// <p>Specifies the public key encoding format to use in the response. To retrieve the public key in ssh-rsa format, use <code>SSH</code>. To retrieve the public key in PEM format, use <code>PEM</code>.</p>
     pub fn encoding(&self) -> ::std::option::Option<&crate::types::EncodingType> {
         self.encoding.as_ref()
-29
+    }
-30
+}
 static GETSSHPUBLICKEYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetSSHPublicKeyInput",

     "com.amazonaws.iam.synthetic",
     "GetSSHPublicKeyInput",
 );
 static GETSSHPUBLICKEYINPUT_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetSSHPublicKeyInput$UserName",
         "com.amazonaws.iam.synthetic",
         "GetSSHPublicKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_name",
     "UserName",
 ,
 );
 static GETSSHPUBLICKEYINPUT_MEMBER_SSH_PUBLIC_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetSSHPublicKeyInput$SSHPublicKeyId",
         "com.amazonaws.iam.synthetic",
         "GetSSHPublicKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "ssh_public_key_id",
     "SSHPublicKeyId",
 ,
 );
 static GETSSHPUBLICKEYINPUT_MEMBER_ENCODING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetSSHPublicKeyInput$Encoding",
         "com.amazonaws.iam.synthetic",
         "GetSSHPublicKeyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "encoding",
     "Encoding",
 ,
 );
 static GETSSHPUBLICKEYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSSHPUBLICKEYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETSSHPUBLICKEYINPUT_MEMBER_USER_NAME,
         &GETSSHPUBLICKEYINPUT_MEMBER_SSH_PUBLIC_KEY_ID,
         &GETSSHPUBLICKEYINPUT_MEMBER_ENCODING,
     ],
 );
 impl GetSshPublicKeyInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSSHPUBLICKEYINPUT_SCHEMA;
-78
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetSshPublicKeyInput {
     #[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.user_name {
             ser.write_string(&GETSSHPUBLICKEYINPUT_MEMBER_USER_NAME, val)?;
-87
+        }
         if let Some(ref val) = self.ssh_public_key_id {
             ser.write_string(&GETSSHPUBLICKEYINPUT_MEMBER_SSH_PUBLIC_KEY_ID, val)?;
-90
+        }
         if let Some(ref val) = self.encoding {
             ser.write_string(&GETSSHPUBLICKEYINPUT_MEMBER_ENCODING, val.as_str())?;
-93
+        }
         Ok(())
-95
+    }
-96
+}
 impl GetSshPublicKeyInput {
     /// 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(&GETSSHPUBLICKEYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSSHPUBLICKEYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user_name = Some(deser.read_string(member)?);
-115
+                }
                 Some(1) => {
                     builder.ssh_public_key_id = Some(deser.read_string(member)?);
-118
+                }
                 Some(2) => {
                     builder.encoding = Some(crate::types::EncodingType::from(deser.read_string(member)?.as_str()));
-121
+                }
                 _ => {}
-123
+            }
             Ok(())
         })?;
         builder.user_name = builder.user_name.or(Some(String::new()));
         builder.ssh_public_key_id = builder.ssh_public_key_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-131
+    }
-132
+}
 impl GetSshPublicKeyInput {
     /// 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 GetSshPublicKeyInput {
     /// Creates a new builder-style object to manufacture [`GetSshPublicKeyInput`](crate::operation::get_ssh_public_key::GetSshPublicKeyInput).
     pub fn builder() -> crate::operation::get_ssh_public_key::builders::GetSshPublicKeyInputBuilder {
         crate::operation::get_ssh_public_key::builders::GetSshPublicKeyInputBuilder::default()
-148
+    }
-149
+}
-150
 /// A builder for [`GetSshPublicKeyInput`](crate::operation::get_ssh_public_key::GetSshPublicKeyInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetSshPublicKeyInputBuilder {
     pub(crate) user_name: ::std::option::Option<::std::string::String>,
     pub(crate) ssh_public_key_id: ::std::option::Option<::std::string::String>,
     pub(crate) encoding: ::std::option::Option<crate::types::EncodingType>,
-158
+}
 impl GetSshPublicKeyInputBuilder {
     /// <p>The name of the IAM user associated with the SSH public key.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     /// This field is required.
     pub fn user_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.user_name = ::std::option::Option::Some(input.into());
         self
-166
+    }
     /// <p>The name of the IAM user associated with the SSH public key.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn set_user_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.user_name = input;
         self
-172
+    }
     /// <p>The name of the IAM user associated with the SSH public key.</p>

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_ssh_public_key/_get_ssh_public_key_output.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Contains the response to a successful <a href="https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetSSHPublicKey.html">GetSSHPublicKey</a> request.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetSshPublicKeyOutput {
     /// <p>A structure containing details about the SSH public key.</p>
     pub ssh_public_key: ::std::option::Option<crate::types::SshPublicKey>,
     _request_id: Option<String>,
-10
+}
 impl GetSshPublicKeyOutput {
     /// <p>A structure containing details about the SSH public key.</p>
     pub fn ssh_public_key(&self) -> ::std::option::Option<&crate::types::SshPublicKey> {
         self.ssh_public_key.as_ref()
-15
+    }
-16
+}
 static GETSSHPUBLICKEYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetSSHPublicKeyOutput",

     "com.amazonaws.iam.synthetic",
     "GetSSHPublicKeyOutput",
 );
 static GETSSHPUBLICKEYOUTPUT_MEMBER_SSH_PUBLIC_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetSSHPublicKeyOutput$SSHPublicKey",
         "com.amazonaws.iam.synthetic",
         "GetSSHPublicKeyOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "ssh_public_key",
     "SSHPublicKey",
 ,
 );
 static GETSSHPUBLICKEYOUTPUT_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 GETSSHPUBLICKEYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETSSHPUBLICKEYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETSSHPUBLICKEYOUTPUT_MEMBER_SSH_PUBLIC_KEY],
     &[&GETSSHPUBLICKEYOUTPUT_MEMBER_SSH_PUBLIC_KEY, &GETSSHPUBLICKEYOUTPUT_MEMBER__REQUEST_ID],
 );
 impl GetSshPublicKeyOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETSSHPUBLICKEYOUTPUT_SCHEMA;
-47
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetSshPublicKeyOutput {
     #[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.ssh_public_key {
             ser.write_struct(&GETSSHPUBLICKEYOUTPUT_MEMBER_SSH_PUBLIC_KEY, val)?;
-56
+        }
         Ok(())
-58
+    }
-59
+}
 impl GetSshPublicKeyOutput {
     /// 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(&GETSSHPUBLICKEYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETSSHPUBLICKEYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.ssh_public_key = Some(crate::types::SshPublicKey::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GetSshPublicKeyOutput {
     /// 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(&GETSSHPUBLICKEYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.ssh_public_key = Some(crate::types::SshPublicKey::deserialize(deser)?);
-115
+                }
                 _ => {}
-117
+            }
             Ok(())
         })?;
         Ok(builder.build())
-121
+    }

↧ Expand context

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

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_user.rs

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

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

@@ -111,115 +173,178 @@

↥ Expand context

         });
-116
         ::std::option::Option::Some(cfg.freeze())
-118
+    }
-119
     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("GetUser")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetUserEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_user::GetUserError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_user::GetUserError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_user::GetUserError,
             >::new());
-137
         ::std::borrow::Cow::Owned(rcb)
-139
+    }
-140
+}
-141
 #[derive(Debug)]
 struct GetUserResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetUserResponseDeserializer {
     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_get_user::de_get_user_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_get_user::de_get_user_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-162
+    }
-163
+}
 #[derive(Debug)]
 struct GetUserRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetUserRequestSerializer {
     #[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::get_user::GetUserInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_user/_get_user_input.rs

@@ -1,1 +107,118 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetUserInput {
     /// <p>The name of the user to get information about.</p>
     /// <p>This parameter is optional. If it is not included, it defaults to the user making the request. This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub user_name: ::std::option::Option<::std::string::String>,
-9
+}
 impl GetUserInput {
     /// <p>The name of the user to get information about.</p>
     /// <p>This parameter is optional. If it is not included, it defaults to the user making the request. This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn user_name(&self) -> ::std::option::Option<&str> {
         self.user_name.as_deref()
-15
+    }

-16
+}
 static GETUSERINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
     ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.iam.synthetic#GetUserInput", "com.amazonaws.iam.synthetic", "GetUserInput");
 static GETUSERINPUT_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetUserInput$UserName",
         "com.amazonaws.iam.synthetic",
         "GetUserInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_name",
     "UserName",
 ,
 );
 static GETUSERINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETUSERINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETUSERINPUT_MEMBER_USER_NAME],
 );
 impl GetUserInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETUSERINPUT_SCHEMA;
-37
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetUserInput {
     #[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.user_name {
             ser.write_string(&GETUSERINPUT_MEMBER_USER_NAME, val)?;
-46
+        }
         Ok(())
-48
+    }
-49
+}
 impl GetUserInput {
     /// 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(&GETUSERINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETUSERINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user_name = Some(deser.read_string(member)?);
-68
+                }
                 _ => {}
-70
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-76
+    }
-77
+}
 impl GetUserInput {
     /// 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 GetUserInput {
     /// Creates a new builder-style object to manufacture [`GetUserInput`](crate::operation::get_user::GetUserInput).
     pub fn builder() -> crate::operation::get_user::builders::GetUserInputBuilder {
         crate::operation::get_user::builders::GetUserInputBuilder::default()
-93
+    }
-94
+}
-95
 /// A builder for [`GetUserInput`](crate::operation::get_user::GetUserInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetUserInputBuilder {
     pub(crate) user_name: ::std::option::Option<::std::string::String>,
-101
+}
 impl GetUserInputBuilder {
     /// <p>The name of the user to get information about.</p>
     /// <p>This parameter is optional. If it is not included, it defaults to the user making the request. This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn user_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.user_name = ::std::option::Option::Some(input.into());
         self
-108
+    }
     /// <p>The name of the user to get information about.</p>
     /// <p>This parameter is optional. If it is not included, it defaults to the user making the request. This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn set_user_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.user_name = input;
         self
-114
+    }
     /// <p>The name of the user to get information about.</p>
     /// <p>This parameter is optional. If it is not included, it defaults to the user making the request. This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn get_user_name(&self) -> &::std::option::Option<::std::string::String> {
         &self.user_name

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_user/_get_user_output.rs

@@ -5,5 +103,147 @@

↥ Expand context

 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetUserOutput {
     /// <p>A structure containing details about the IAM user.</p><important>
     /// <p>Due to a service issue, password last used data does not include password use from May 3, 2018 22:50 PDT to May 23, 2018 14:08 PDT. This affects <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_finding-unused.html">last sign-in</a> dates shown in the IAM console and password last used dates in the <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_getting-report.html">IAM credential report</a>, and returned by this operation. If users signed in during the affected time, the password last used date that is returned is the date the user last signed in before May 3, 2018. For users that signed in after May 23, 2018 14:08 PDT, the returned password last used date is accurate.</p>
     /// <p>You can use password last used information to identify unused credentials for deletion. For example, you might delete users who did not sign in to Amazon Web Services in the last 90 days. In cases like this, we recommend that you adjust your evaluation window to include dates after May 23, 2018. Alternatively, if your users use access keys to access Amazon Web Services programmatically you can refer to access key last used information because it is accurate for all dates.</p>
     /// </important>
     pub user: ::std::option::Option<crate::types::User>,
     _request_id: Option<String>,
-13
+}
 impl GetUserOutput {
     /// <p>A structure containing details about the IAM user.</p><important>
     /// <p>Due to a service issue, password last used data does not include password use from May 3, 2018 22:50 PDT to May 23, 2018 14:08 PDT. This affects <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_finding-unused.html">last sign-in</a> dates shown in the IAM console and password last used dates in the <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_getting-report.html">IAM credential report</a>, and returned by this operation. If users signed in during the affected time, the password last used date that is returned is the date the user last signed in before May 3, 2018. For users that signed in after May 23, 2018 14:08 PDT, the returned password last used date is accurate.</p>
     /// <p>You can use password last used information to identify unused credentials for deletion. For example, you might delete users who did not sign in to Amazon Web Services in the last 90 days. In cases like this, we recommend that you adjust your evaluation window to include dates after May 23, 2018. Alternatively, if your users use access keys to access Amazon Web Services programmatically you can refer to access key last used information because it is accurate for all dates.</p>
     /// </important>
     pub fn user(&self) -> ::std::option::Option<&crate::types::User> {
         self.user.as_ref()
-21
+    }
-22
+}
 static GETUSEROUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetUserOutput",

     "com.amazonaws.iam.synthetic",
     "GetUserOutput",
 );
 static GETUSEROUTPUT_MEMBER_USER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetUserOutput$User",
         "com.amazonaws.iam.synthetic",
         "GetUserOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "user",
     "User",
 ,
 );
 static GETUSEROUTPUT_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 GETUSEROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETUSEROUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETUSEROUTPUT_MEMBER_USER],
     &[&GETUSEROUTPUT_MEMBER_USER, &GETUSEROUTPUT_MEMBER__REQUEST_ID],
 );
 impl GetUserOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETUSEROUTPUT_SCHEMA;
-53
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetUserOutput {
     #[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.user {
             ser.write_struct(&GETUSEROUTPUT_MEMBER_USER, val)?;
-62
+        }
         Ok(())
-64
+    }
-65
+}
 impl GetUserOutput {
     /// 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(&GETUSEROUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETUSEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user = Some(crate::types::User::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl GetUserOutput {
     /// 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(&GETUSEROUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user = Some(crate::types::User::deserialize(deser)?);
-121
+                }
                 _ => {}
-123
+            }
             Ok(())
         })?;
         Ok(builder.build())
-127
+    }

↧ Expand context

-128
+}
 impl ::aws_types::request_id::RequestId for GetUserOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-132
+    }
-133
+}
 impl GetUserOutput {
     /// Creates a new builder-style object to manufacture [`GetUserOutput`](crate::operation::get_user::GetUserOutput).
     pub fn builder() -> crate::operation::get_user::builders::GetUserOutputBuilder {
         crate::operation::get_user::builders::GetUserOutputBuilder::default()
-138
+    }
-139
+}
-140
 /// A builder for [`GetUserOutput`](crate::operation::get_user::GetUserOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetUserOutputBuilder {
     pub(crate) user: ::std::option::Option<crate::types::User>,
     _request_id: Option<String>,
-147
+}

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_user_policy.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `GetUserPolicy`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetUserPolicy;
 impl GetUserPolicy {
     /// Creates a new `GetUserPolicy`
     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::get_user_policy::GetUserPolicyInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_user_policy::GetUserPolicyOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_user_policy::GetUserPolicyInput,
     ) -> ::std::result::Result<
         crate::operation::get_user_policy::GetUserPolicyOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_user_policy::GetUserPolicyError,
             ::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::get_user_policy::GetUserPolicyError>()
                     .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::get_user_policy::GetUserPolicyOutput>()
                 .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("GetUserPolicy")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetUserPolicyEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_user_policy::GetUserPolicyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_user_policy::GetUserPolicyError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_user_policy::GetUserPolicyError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct GetUserPolicyResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetUserPolicyResponseDeserializer {
     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_get_user_policy::de_get_user_policy_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_get_user_policy::de_get_user_policy_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}
 #[derive(Debug)]
 struct GetUserPolicyRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetUserPolicyRequestSerializer {
     #[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::get_user_policy::GetUserPolicyInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_user_policy/_get_user_policy_input.rs

@@ -7,7 +134,147 @@

↥ Expand context

     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub user_name: ::std::option::Option<::std::string::String>,
     /// <p>The name of the policy document to get.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub policy_name: ::std::option::Option<::std::string::String>,
-12
+}
 impl GetUserPolicyInput {
     /// <p>The name of the user who the policy is associated with.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn user_name(&self) -> ::std::option::Option<&str> {
         self.user_name.as_deref()
-18
+    }
     /// <p>The name of the policy document to get.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn policy_name(&self) -> ::std::option::Option<&str> {
         self.policy_name.as_deref()
-23
+    }
-24
+}
 static GETUSERPOLICYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetUserPolicyInput",

     "com.amazonaws.iam.synthetic",
     "GetUserPolicyInput",
 );
 static GETUSERPOLICYINPUT_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetUserPolicyInput$UserName",
         "com.amazonaws.iam.synthetic",
         "GetUserPolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_name",
     "UserName",
 ,
 );
 static GETUSERPOLICYINPUT_MEMBER_POLICY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetUserPolicyInput$PolicyName",
         "com.amazonaws.iam.synthetic",
         "GetUserPolicyInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "policy_name",
     "PolicyName",
 ,
 );
 static GETUSERPOLICYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETUSERPOLICYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETUSERPOLICYINPUT_MEMBER_USER_NAME, &GETUSERPOLICYINPUT_MEMBER_POLICY_NAME],
 );
 impl GetUserPolicyInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETUSERPOLICYINPUT_SCHEMA;
-58
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetUserPolicyInput {
     #[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.user_name {
             ser.write_string(&GETUSERPOLICYINPUT_MEMBER_USER_NAME, val)?;
-67
+        }
         if let Some(ref val) = self.policy_name {
             ser.write_string(&GETUSERPOLICYINPUT_MEMBER_POLICY_NAME, val)?;
-70
+        }
         Ok(())
-72
+    }
-73
+}
 impl GetUserPolicyInput {
     /// 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(&GETUSERPOLICYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETUSERPOLICYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user_name = Some(deser.read_string(member)?);
-92
+                }
                 Some(1) => {
                     builder.policy_name = Some(deser.read_string(member)?);
-95
+                }
                 _ => {}
-97
+            }
             Ok(())
         })?;
         builder.user_name = builder.user_name.or(Some(String::new()));
         builder.policy_name = builder.policy_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-105
+    }
-106
+}
 impl GetUserPolicyInput {
     /// 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 GetUserPolicyInput {
     /// Creates a new builder-style object to manufacture [`GetUserPolicyInput`](crate::operation::get_user_policy::GetUserPolicyInput).
     pub fn builder() -> crate::operation::get_user_policy::builders::GetUserPolicyInputBuilder {
         crate::operation::get_user_policy::builders::GetUserPolicyInputBuilder::default()
-122
+    }
-123
+}
-124
 /// A builder for [`GetUserPolicyInput`](crate::operation::get_user_policy::GetUserPolicyInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct GetUserPolicyInputBuilder {
     pub(crate) user_name: ::std::option::Option<::std::string::String>,
     pub(crate) policy_name: ::std::option::Option<::std::string::String>,
-131
+}
 impl GetUserPolicyInputBuilder {
     /// <p>The name of the user who the policy is associated with.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     /// This field is required.
     pub fn user_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.user_name = ::std::option::Option::Some(input.into());
         self
-139
+    }
     /// <p>The name of the user who the policy is associated with.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn set_user_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.user_name = input;
         self
-145
+    }
     /// <p>The name of the user who the policy is associated with.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/get_user_policy/_get_user_policy_output.rs

@@ -16,16 +147,203 @@

↥ Expand context

 impl GetUserPolicyOutput {
     /// <p>The user the policy is associated with.</p>
     pub fn user_name(&self) -> &str {
         use std::ops::Deref;
         self.user_name.deref()
-21
+    }
     /// <p>The name of the policy.</p>
     pub fn policy_name(&self) -> &str {
         use std::ops::Deref;
         self.policy_name.deref()
-26
+    }
     /// <p>The policy document.</p>
     /// <p>IAM stores policies in JSON format. However, resources that were created using CloudFormation templates can be formatted in YAML. CloudFormation always converts a YAML policy to JSON format before submitting it to IAM.</p>
     pub fn policy_document(&self) -> &str {
         use std::ops::Deref;
         self.policy_document.deref()
-32
+    }
-33
+}
 static GETUSERPOLICYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#GetUserPolicyOutput",

     "com.amazonaws.iam.synthetic",
     "GetUserPolicyOutput",
 );
 static GETUSERPOLICYOUTPUT_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetUserPolicyOutput$UserName",
         "com.amazonaws.iam.synthetic",
         "GetUserPolicyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_name",
     "UserName",
 ,
 );
 static GETUSERPOLICYOUTPUT_MEMBER_POLICY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetUserPolicyOutput$PolicyName",
         "com.amazonaws.iam.synthetic",
         "GetUserPolicyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "policy_name",
     "PolicyName",
 ,
 );
 static GETUSERPOLICYOUTPUT_MEMBER_POLICY_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#GetUserPolicyOutput$PolicyDocument",
         "com.amazonaws.iam.synthetic",
         "GetUserPolicyOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "policy_document",
     "PolicyDocument",
 ,
 );
 static GETUSERPOLICYOUTPUT_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 GETUSERPOLICYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETUSERPOLICYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETUSERPOLICYOUTPUT_MEMBER_USER_NAME,
         &GETUSERPOLICYOUTPUT_MEMBER_POLICY_NAME,
         &GETUSERPOLICYOUTPUT_MEMBER_POLICY_DOCUMENT,
         &GETUSERPOLICYOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetUserPolicyOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETUSERPOLICYOUTPUT_SCHEMA;
-89
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetUserPolicyOutput {
     #[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> {
-96
+        {
             let val = &self.user_name;
             ser.write_string(&GETUSERPOLICYOUTPUT_MEMBER_USER_NAME, val)?;
-99
+        }
-100
+        {
             let val = &self.policy_name;
             ser.write_string(&GETUSERPOLICYOUTPUT_MEMBER_POLICY_NAME, val)?;
-103
+        }
-104
+        {
             let val = &self.policy_document;
             ser.write_string(&GETUSERPOLICYOUTPUT_MEMBER_POLICY_DOCUMENT, val)?;
-107
+        }
         Ok(())
-109
+    }
-110
+}
 impl GetUserPolicyOutput {
     /// 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(&GETUSERPOLICYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETUSERPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user_name = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.policy_name = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.policy_document = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.user_name = builder.user_name.or(Some(String::new()));
         builder.policy_name = builder.policy_name.or(Some(String::new()));
         builder.policy_document = builder.policy_document.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl GetUserPolicyOutput {
     /// 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(&GETUSERPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user_name = Some(deser.read_string(member)?);
-177
+                }
                 Some(1) => {
                     builder.policy_name = Some(deser.read_string(member)?);
-180
+                }
                 Some(2) => {
                     builder.policy_document = Some(deser.read_string(member)?);
-183
+                }

↧ Expand context

                 _ => {}
-185
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-191
+    }
-192
+}
 impl ::aws_types::request_id::RequestId for GetUserPolicyOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-196
+    }
-197
+}
 impl GetUserPolicyOutput {
     /// Creates a new builder-style object to manufacture [`GetUserPolicyOutput`](crate::operation::get_user_policy::GetUserPolicyOutput).
     pub fn builder() -> crate::operation::get_user_policy::builders::GetUserPolicyOutputBuilder {
         crate::operation::get_user_policy::builders::GetUserPolicyOutputBuilder::default()
-202
+    }
-203
+}

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/list_access_keys.rs

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `ListAccessKeys`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListAccessKeys;
 impl ListAccessKeys {
     /// Creates a new `ListAccessKeys`
     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_access_keys::ListAccessKeysInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::list_access_keys::ListAccessKeysOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::list_access_keys::ListAccessKeysInput,
     ) -> ::std::result::Result<
         crate::operation::list_access_keys::ListAccessKeysOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_access_keys::ListAccessKeysError,
             ::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_access_keys::ListAccessKeysError>()
                     .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_access_keys::ListAccessKeysOutput>()
                 .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("ListAccessKeys")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListAccessKeysEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_access_keys::ListAccessKeysError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_access_keys::ListAccessKeysError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_access_keys::ListAccessKeysError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct ListAccessKeysResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListAccessKeysResponseDeserializer {
     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_access_keys::de_list_access_keys_http_error(status, headers, body)
         } else {

↧ Expand context

             crate::protocol_serde::shape_list_access_keys::de_list_access_keys_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-166
+    }
-167
+}
 #[derive(Debug)]
 struct ListAccessKeysRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListAccessKeysRequestSerializer {
     #[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_access_keys::ListAccessKeysInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/list_access_keys/_list_access_keys_input.rs

@@ -13,13 +160,171 @@

↥ Expand context

     pub max_items: ::std::option::Option<i32>,
-14
+}
 impl ListAccessKeysInput {
     /// <p>The name of the user.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn user_name(&self) -> ::std::option::Option<&str> {
         self.user_name.as_deref()
-20
+    }
     /// <p>Use this parameter only when paginating results and only after you receive a response indicating that the results are truncated. Set it to the value of the <code>Marker</code> element in the response that you received to indicate where the next call should start.</p>
     pub fn marker(&self) -> ::std::option::Option<&str> {
         self.marker.as_deref()
-24
+    }
     /// <p>Use this only when paginating results to indicate the maximum number of items you want in the response. If additional items exist beyond the maximum you specify, the <code>IsTruncated</code> response element is <code>true</code>.</p>
     /// <p>If you do not include this parameter, the number of items defaults to 100. Note that IAM might return fewer results, even when there are more results available. In that case, the <code>IsTruncated</code> response element returns <code>true</code>, and <code>Marker</code> contains a value to include in the subsequent call that tells the service where to continue from.</p>
     pub fn max_items(&self) -> ::std::option::Option<i32> {
         self.max_items
-29
+    }
-30
+}
 static LISTACCESSKEYSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#ListAccessKeysInput",

     "com.amazonaws.iam.synthetic",
     "ListAccessKeysInput",
 );
 static LISTACCESSKEYSINPUT_MEMBER_USER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#ListAccessKeysInput$UserName",
         "com.amazonaws.iam.synthetic",
         "ListAccessKeysInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_name",
     "UserName",
 ,
 );
 static LISTACCESSKEYSINPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#ListAccessKeysInput$Marker",
         "com.amazonaws.iam.synthetic",
         "ListAccessKeysInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "marker",
     "Marker",
 ,
 );
 static LISTACCESSKEYSINPUT_MEMBER_MAX_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#ListAccessKeysInput$MaxItems",
         "com.amazonaws.iam.synthetic",
         "ListAccessKeysInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_items",
     "MaxItems",
 ,
 );
 static LISTACCESSKEYSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTACCESSKEYSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTACCESSKEYSINPUT_MEMBER_USER_NAME,
         &LISTACCESSKEYSINPUT_MEMBER_MARKER,
         &LISTACCESSKEYSINPUT_MEMBER_MAX_ITEMS,
     ],
 );
 impl ListAccessKeysInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTACCESSKEYSINPUT_SCHEMA;
-78
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListAccessKeysInput {
     #[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.user_name {
             ser.write_string(&LISTACCESSKEYSINPUT_MEMBER_USER_NAME, val)?;
-87
+        }
         if let Some(ref val) = self.marker {
             ser.write_string(&LISTACCESSKEYSINPUT_MEMBER_MARKER, val)?;
-90
+        }
         if let Some(ref val) = self.max_items {
             ser.write_integer(&LISTACCESSKEYSINPUT_MEMBER_MAX_ITEMS, *val)?;
-93
+        }
         Ok(())
-95
+    }
-96
+}
 impl ListAccessKeysInput {
     /// 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(&LISTACCESSKEYSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTACCESSKEYSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.user_name = Some(deser.read_string(member)?);
-115
+                }
                 Some(1) => {
                     builder.marker = Some(deser.read_string(member)?);
-118
+                }
                 Some(2) => {
                     builder.max_items = Some(deser.read_integer(member)?);
-121
+                }
                 _ => {}
-123
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-129
+    }
-130
+}
 impl ListAccessKeysInput {
     /// 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 ListAccessKeysInput {
     /// Creates a new builder-style object to manufacture [`ListAccessKeysInput`](crate::operation::list_access_keys::ListAccessKeysInput).
     pub fn builder() -> crate::operation::list_access_keys::builders::ListAccessKeysInputBuilder {
         crate::operation::list_access_keys::builders::ListAccessKeysInputBuilder::default()
-146
+    }
-147
+}
-148
 /// A builder for [`ListAccessKeysInput`](crate::operation::list_access_keys::ListAccessKeysInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListAccessKeysInputBuilder {
     pub(crate) user_name: ::std::option::Option<::std::string::String>,
     pub(crate) marker: ::std::option::Option<::std::string::String>,
     pub(crate) max_items: ::std::option::Option<i32>,
-156
+}
 impl ListAccessKeysInputBuilder {
     /// <p>The name of the user.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn user_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.user_name = ::std::option::Option::Some(input.into());
         self
-163
+    }
     /// <p>The name of the user.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>
     pub fn set_user_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.user_name = input;
         self
-169
+    }
     /// <p>The name of the user.</p>
     /// <p>This parameter allows (through its <a href="http://wikipedia.org/wiki/regex">regex pattern</a>) a string of characters consisting of upper and lowercase alphanumeric characters with no spaces. You can also include any of the following characters: _+=,.@-</p>

tmp-codegen-diff/aws-sdk/sdk/iam/src/operation/list_access_keys/_list_access_keys_output.rs

@@ -12,12 +163,221 @@

↥ Expand context

     pub marker: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-14
+}
 impl ListAccessKeysOutput {
     /// <p>A list of objects containing metadata about the access keys.</p>
     pub fn access_key_metadata(&self) -> &[crate::types::AccessKeyMetadata] {
         use std::ops::Deref;
         self.access_key_metadata.deref()
-20
+    }
     /// <p>A flag that indicates whether there are more items to return. If your results were truncated, you can make a subsequent pagination request using the <code>Marker</code> request parameter to retrieve more items. Note that IAM might return fewer than the <code>MaxItems</code> number of results even when there are more results available. We recommend that you check <code>IsTruncated</code> after every call to ensure that you receive all your results.</p>
     pub fn is_truncated(&self) -> bool {
         self.is_truncated
-24
+    }
     /// <p>When <code>IsTruncated</code> is <code>true</code>, this element is present and contains the value to use for the <code>Marker</code> parameter in a subsequent pagination request.</p>
     pub fn marker(&self) -> ::std::option::Option<&str> {
         self.marker.as_deref()
-28
+    }
-29
+}
 static LISTACCESSKEYSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.iam.synthetic#ListAccessKeysOutput",

     "com.amazonaws.iam.synthetic",
     "ListAccessKeysOutput",
 );
 static LISTACCESSKEYSOUTPUT_MEMBER_ACCESS_KEY_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#ListAccessKeysOutput$AccessKeyMetadata",
         "com.amazonaws.iam.synthetic",
         "ListAccessKeysOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "access_key_metadata",
     "AccessKeyMetadata",
 ,
 );
 static LISTACCESSKEYSOUTPUT_MEMBER_IS_TRUNCATED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#ListAccessKeysOutput$IsTruncated",
         "com.amazonaws.iam.synthetic",
         "ListAccessKeysOutput",
     ),
     ::aws_smithy_schema::ShapeType::Boolean,
     "is_truncated",
     "IsTruncated",
 ,
 );
 static LISTACCESSKEYSOUTPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.iam.synthetic#ListAccessKeysOutput$Marker",
         "com.amazonaws.iam.synthetic",
         "ListAccessKeysOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "marker",
     "Marker",
 ,
 );
 static LISTACCESSKEYSOUTPUT_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 LISTACCESSKEYSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTACCESSKEYSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTACCESSKEYSOUTPUT_MEMBER_ACCESS_KEY_METADATA,
         &LISTACCESSKEYSOUTPUT_MEMBER_IS_TRUNCATED,
         &LISTACCESSKEYSOUTPUT_MEMBER_MARKER,
         &LISTACCESSKEYSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListAccessKeysOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTACCESSKEYSOUTPUT_SCHEMA;
-85
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListAccessKeysOutput {
     #[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> {
-92
+        {
             let val = &self.access_key_metadata;
-94
             ser.write_list(
                 &LISTACCESSKEYSOUTPUT_MEMBER_ACCESS_KEY_METADATA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::AccessKeyMetadata::SCHEMA, item)?;
-100
+                    }
                     Ok(())
                 },
             )?;
-104
+        }
-105
+        {
             let val = &self.is_truncated;
             ser.write_boolean(&LISTACCESSKEYSOUTPUT_MEMBER_IS_TRUNCATED, *val)?;
-108
+        }
         if let Some(ref val) = self.marker {
             ser.write_string(&LISTACCESSKEYSOUTPUT_MEMBER_MARKER, val)?;
-111
+        }
         Ok(())
-113
+    }
-114
+}
 impl ListAccessKeysOutput {
     /// 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(&LISTACCESSKEYSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.access_key_metadata = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::AccessKeyMetadata::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-+
+                }
                 Some(2) => {
                     builder.marker = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.access_key_metadata = builder.access_key_metadata.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl ListAccessKeysOutput {
     /// 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(&LISTACCESSKEYSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTACCESSKEYSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.access_key_metadata = 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::AccessKeyMetadata::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::AccessKeyMetadata::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-193
+                }
                 Some(1) => {
                     builder.is_truncated = Some(deser.read_boolean(member)?);
-196
+                }
                 Some(2) => {
                     builder.marker = Some(deser.read_string(member)?);
-199
+                }
                 _ => {}
-201
+            }

↧ Expand context

             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-207
+    }
-208
+}
 impl ::aws_types::request_id::RequestId for ListAccessKeysOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-212
+    }
-213
+}
 impl ListAccessKeysOutput {
     /// Creates a new builder-style object to manufacture [`ListAccessKeysOutput`](crate::operation::list_access_keys::ListAccessKeysOutput).
     pub fn builder() -> crate::operation::list_access_keys::builders::ListAccessKeysOutputBuilder {
         crate::operation::list_access_keys::builders::ListAccessKeysOutputBuilder::default()
-218
+    }
-219
+}
-220
 /// A builder for [`ListAccessKeysOutput`](crate::operation::list_access_keys::ListAccessKeysOutput).

AWS SDK

Files changed: