AWS SDK

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/create_token_with_iam/_create_token_with_iam_output.rs

@@ -63,63 +301,357 @@

         self.aws_additional_details.as_ref()
-64
+    }
-65
+}
 impl ::std::fmt::Debug for CreateTokenWithIamOutput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("CreateTokenWithIamOutput");
         formatter.field("access_token", &"*** Sensitive Data Redacted ***");
         formatter.field("token_type", &self.token_type);
         formatter.field("expires_in", &self.expires_in);
         formatter.field("refresh_token", &"*** Sensitive Data Redacted ***");
         formatter.field("id_token", &"*** Sensitive Data Redacted ***");
         formatter.field("issued_token_type", &self.issued_token_type);
         formatter.field("scope", &self.scope);
         formatter.field("aws_additional_details", &self.aws_additional_details);
         formatter.field("_request_id", &self._request_id);
         formatter.finish()
-79
+    }
-80
+}
 static CREATETOKENWITHIAMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput",

     "com.amazonaws.ssooidc.synthetic",
     "CreateTokenWithIAMOutput",
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_ACCESS_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$accessToken",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "access_token",
     "accessToken",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_TOKEN_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$tokenType",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "token_type",
     "tokenType",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_EXPIRES_IN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$expiresIn",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "expires_in",
     "expiresIn",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_REFRESH_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$refreshToken",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "refresh_token",
     "refreshToken",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_ID_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$idToken",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "id_token",
     "idToken",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_ISSUED_TOKEN_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$issuedTokenType",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "issued_token_type",
     "issuedTokenType",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$scope",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "scope",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_MEMBER_AWS_ADDITIONAL_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#CreateTokenWithIAMOutput$awsAdditionalDetails",
         "com.amazonaws.ssooidc.synthetic",
         "CreateTokenWithIAMOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "aws_additional_details",
     "awsAdditionalDetails",
 ,
 );
 static CREATETOKENWITHIAMOUTPUT_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 CREATETOKENWITHIAMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CREATETOKENWITHIAMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CREATETOKENWITHIAMOUTPUT_MEMBER_ACCESS_TOKEN,
         &CREATETOKENWITHIAMOUTPUT_MEMBER_TOKEN_TYPE,
         &CREATETOKENWITHIAMOUTPUT_MEMBER_EXPIRES_IN,
         &CREATETOKENWITHIAMOUTPUT_MEMBER_REFRESH_TOKEN,
         &CREATETOKENWITHIAMOUTPUT_MEMBER_ID_TOKEN,
         &CREATETOKENWITHIAMOUTPUT_MEMBER_ISSUED_TOKEN_TYPE,
         &CREATETOKENWITHIAMOUTPUT_MEMBER_SCOPE,
         &CREATETOKENWITHIAMOUTPUT_MEMBER_AWS_ADDITIONAL_DETAILS,
         &CREATETOKENWITHIAMOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl CreateTokenWithIamOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETOKENWITHIAMOUTPUT_SCHEMA;
-191
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CreateTokenWithIamOutput {
     #[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.access_token {
             ser.write_string(&CREATETOKENWITHIAMOUTPUT_MEMBER_ACCESS_TOKEN, val)?;
-200
+        }
         if let Some(ref val) = self.token_type {
             ser.write_string(&CREATETOKENWITHIAMOUTPUT_MEMBER_TOKEN_TYPE, val)?;
-203
+        }
-204
+        {
             let val = &self.expires_in;
             ser.write_integer(&CREATETOKENWITHIAMOUTPUT_MEMBER_EXPIRES_IN, *val)?;
-207
+        }
         if let Some(ref val) = self.refresh_token {
             ser.write_string(&CREATETOKENWITHIAMOUTPUT_MEMBER_REFRESH_TOKEN, val)?;
-210
+        }
         if let Some(ref val) = self.id_token {
             ser.write_string(&CREATETOKENWITHIAMOUTPUT_MEMBER_ID_TOKEN, val)?;
-213
+        }
         if let Some(ref val) = self.issued_token_type {
             ser.write_string(&CREATETOKENWITHIAMOUTPUT_MEMBER_ISSUED_TOKEN_TYPE, val)?;
-216
+        }
         if let Some(ref val) = self.scope {
             ser.write_list(
                 &CREATETOKENWITHIAMOUTPUT_MEMBER_SCOPE,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-223
+                    }
                     Ok(())
                 },
             )?;
-227
+        }
         if let Some(ref val) = self.aws_additional_details {
             ser.write_struct(&CREATETOKENWITHIAMOUTPUT_MEMBER_AWS_ADDITIONAL_DETAILS, val)?;
-230
+        }
         Ok(())
-232
+    }
-233
+}
 impl CreateTokenWithIamOutput {
     /// 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(&CREATETOKENWITHIAMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CREATETOKENWITHIAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.access_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.token_type = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.expires_in = Some(deser.read_integer(member)?);
-+
+                }
                 Some(3) => {
                     builder.refresh_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(4) => {
                     builder.id_token = Some(deser.read_string(member)?);
-+
+                }
                 Some(5) => {
                     builder.issued_token_type = Some(deser.read_string(member)?);
-+
+                }
                 Some(6) => {
                     builder.scope = Some(deser.read_string_list(member)?);
-+
+                }
                 Some(7) => {
                     builder.aws_additional_details = Some(crate::types::AwsAdditionalDetails::deserialize(deser)?);
-+
+                }
                 Some(8) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl CreateTokenWithIamOutput {
     /// 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(&CREATETOKENWITHIAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.access_token = Some(deser.read_string(member)?);
-310
+                }
                 Some(1) => {
                     builder.token_type = Some(deser.read_string(member)?);
-313
+                }
                 Some(2) => {
                     builder.expires_in = Some(deser.read_integer(member)?);
-316
+                }
                 Some(3) => {
                     builder.refresh_token = Some(deser.read_string(member)?);
-319
+                }
                 Some(4) => {
                     builder.id_token = Some(deser.read_string(member)?);
-322
+                }
                 Some(5) => {
                     builder.issued_token_type = Some(deser.read_string(member)?);
-325
+                }
                 Some(6) => {
                     builder.scope = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.scope = Some(deser.read_string_list(member)?);
-328
+                }
                 Some(7) => {
                     builder.aws_additional_details = Some(crate::types::AwsAdditionalDetails::deserialize(deser)?);
-331
+                }
                 _ => {}
-333
+            }
             Ok(())
         })?;
         Ok(builder.build())
-337
+    }

↧ Expand context

-338
+}
 impl ::aws_types::request_id::RequestId for CreateTokenWithIamOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-342
+    }
-343
+}
 impl CreateTokenWithIamOutput {
     /// Creates a new builder-style object to manufacture [`CreateTokenWithIamOutput`](crate::operation::create_token_with_iam::CreateTokenWithIamOutput).
     pub fn builder() -> crate::operation::create_token_with_iam::builders::CreateTokenWithIamOutputBuilder {
         crate::operation::create_token_with_iam::builders::CreateTokenWithIamOutputBuilder::default()
-348
+    }
-349
+}
-350
 /// A builder for [`CreateTokenWithIamOutput`](crate::operation::create_token_with_iam::CreateTokenWithIamOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct CreateTokenWithIamOutputBuilder {
     pub(crate) access_token: ::std::option::Option<::std::string::String>,
     pub(crate) token_type: ::std::option::Option<::std::string::String>,
     pub(crate) expires_in: ::std::option::Option<i32>,

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/register_client.rs

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

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

@@ -109,113 +231,421 @@

↥ Expand context

         ));
-114
         ::std::option::Option::Some(cfg.freeze())
-116
+    }
-117
     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("RegisterClient")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(RegisterClientEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::register_client::RegisterClientError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::register_client::RegisterClientError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::register_client::RegisterClientError,
             >::new());
-135
         ::std::borrow::Cow::Owned(rcb)
-137
+    }
-138
+}
-139
 #[derive(Debug)]
 struct RegisterClientResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RegisterClientResponseDeserializer {
     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_register_client::de_register_client_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_register_client::de_register_client_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::register_client::RegisterClientError::unhandled(
                             generic,
                         )),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InternalServerException" => crate::operation::register_client::RegisterClientError::InternalServerException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidClientMetadataException" => crate::operation::register_client::RegisterClientError::InvalidClientMetadataException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidClientMetadataException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidClientMetadataException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidRedirectUriException" => crate::operation::register_client::RegisterClientError::InvalidRedirectUriException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidRedirectUriException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidRedirectUriException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidRequestException" => crate::operation::register_client::RegisterClientError::InvalidRequestException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidRequestException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidRequestException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidScopeException" => crate::operation::register_client::RegisterClientError::InvalidScopeException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidScopeException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidScopeException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "SlowDownException" => crate::operation::register_client::RegisterClientError::SlowDownException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::SlowDownException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::SlowDownException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "UnsupportedGrantTypeException" => crate::operation::register_client::RegisterClientError::UnsupportedGrantTypeException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::UnsupportedGrantTypeException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::UnsupportedGrantTypeException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::register_client::RegisterClientError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, RegisterClient::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::register_client::RegisterClientOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-370
+    }
-371
+}
 #[derive(Debug)]
 struct RegisterClientRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RegisterClientRequestSerializer {
     #[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::register_client::RegisterClientInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::register_client::RegisterClientInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/client/register").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::register_client::RegisterClientInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_register_client::ser_register_client_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, RegisterClient::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-392
+    }
-393
+}
 #[derive(Debug)]
 struct RegisterClientEndpointParamsInterceptor;
-396
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RegisterClientEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "RegisterClientEndpointParamsInterceptor"
-400
+    }
-401

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<RegisterClientInput>()
             .ok_or("failed to downcast to RegisterClientInput")?;
-416
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/register_client/_register_client_input.rs

@@ -45,45 +314,298 @@

↥ Expand context

     /// <p>The list of OAuth 2.0 grant types that are defined by the client. This list is used to restrict the token granting flows available to the client. Supports the following OAuth 2.0 grant types: Authorization Code, Device Code, and Refresh Token.</p>
     /// <p>* Authorization Code - <code>authorization_code</code></p>
     /// <p>* Device Code - <code>urn:ietf:params:oauth:grant-type:device_code</code></p>
     /// <p>* Refresh Token - <code>refresh_token</code></p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.grant_types.is_none()`.
     pub fn grant_types(&self) -> &[::std::string::String] {
         self.grant_types.as_deref().unwrap_or_default()
-53
+    }
     /// <p>The IAM Identity Center Issuer URL associated with an instance of IAM Identity Center. This value is needed for user access to resources through the client.</p>
     pub fn issuer_url(&self) -> ::std::option::Option<&str> {
         self.issuer_url.as_deref()
-57
+    }
     /// <p>This IAM Identity Center application ARN is used to define administrator-managed configuration for public client access to resources. At authorization, the scopes, grants, and redirect URI available to this client will be restricted by this application resource.</p>
     pub fn entitled_application_arn(&self) -> ::std::option::Option<&str> {
         self.entitled_application_arn.as_deref()
-61
+    }
-62
+}
 static REGISTERCLIENTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ssooidc.synthetic#RegisterClientInput",

     "com.amazonaws.ssooidc.synthetic",
     "RegisterClientInput",
 );
 static REGISTERCLIENTINPUT_MEMBER_CLIENT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientInput$clientName",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_name",
     "clientName",
 ,
 );
 static REGISTERCLIENTINPUT_MEMBER_CLIENT_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientInput$clientType",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_type",
     "clientType",
 ,
 );
 static REGISTERCLIENTINPUT_MEMBER_SCOPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientInput$scopes",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "scopes",
 ,
 );
 static REGISTERCLIENTINPUT_MEMBER_REDIRECT_URIS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientInput$redirectUris",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "redirect_uris",
     "redirectUris",
 ,
 );
 static REGISTERCLIENTINPUT_MEMBER_GRANT_TYPES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientInput$grantTypes",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "grant_types",
     "grantTypes",
 ,
 );
 static REGISTERCLIENTINPUT_MEMBER_ISSUER_URL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientInput$issuerUrl",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "issuer_url",
     "issuerUrl",
 ,
 );
 static REGISTERCLIENTINPUT_MEMBER_ENTITLED_APPLICATION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientInput$entitledApplicationArn",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "entitled_application_arn",
     "entitledApplicationArn",
 ,
 );
 static REGISTERCLIENTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REGISTERCLIENTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REGISTERCLIENTINPUT_MEMBER_CLIENT_NAME,
         &REGISTERCLIENTINPUT_MEMBER_CLIENT_TYPE,
         &REGISTERCLIENTINPUT_MEMBER_SCOPES,
         &REGISTERCLIENTINPUT_MEMBER_REDIRECT_URIS,
         &REGISTERCLIENTINPUT_MEMBER_GRANT_TYPES,
         &REGISTERCLIENTINPUT_MEMBER_ISSUER_URL,
         &REGISTERCLIENTINPUT_MEMBER_ENTITLED_APPLICATION_ARN,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/client/register", None));
 impl RegisterClientInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REGISTERCLIENTINPUT_SCHEMA;
-155
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RegisterClientInput {
     #[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.client_name {
             ser.write_string(&REGISTERCLIENTINPUT_MEMBER_CLIENT_NAME, val)?;
-164
+        }
         if let Some(ref val) = self.client_type {
             ser.write_string(&REGISTERCLIENTINPUT_MEMBER_CLIENT_TYPE, val)?;
-167
+        }
         if let Some(ref val) = self.scopes {
             ser.write_list(
                 &REGISTERCLIENTINPUT_MEMBER_SCOPES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-174
+                    }
                     Ok(())
                 },
             )?;
-178
+        }
         if let Some(ref val) = self.redirect_uris {
             ser.write_list(
                 &REGISTERCLIENTINPUT_MEMBER_REDIRECT_URIS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-185
+                    }
                     Ok(())
                 },
             )?;
-189
+        }
         if let Some(ref val) = self.grant_types {
             ser.write_list(
                 &REGISTERCLIENTINPUT_MEMBER_GRANT_TYPES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-196
+                    }
                     Ok(())
                 },
             )?;
-200
+        }
         if let Some(ref val) = self.issuer_url {
             ser.write_string(&REGISTERCLIENTINPUT_MEMBER_ISSUER_URL, val)?;
-203
+        }
         if let Some(ref val) = self.entitled_application_arn {
             ser.write_string(&REGISTERCLIENTINPUT_MEMBER_ENTITLED_APPLICATION_ARN, val)?;
-206
+        }
         Ok(())
-208
+    }
-209
+}
 impl RegisterClientInput {
     /// 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(&REGISTERCLIENTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REGISTERCLIENTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.client_name = Some(deser.read_string(member)?);
-228
+                }
                 Some(1) => {
                     builder.client_type = Some(deser.read_string(member)?);
-231
+                }
                 Some(2) => {
                     builder.scopes = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.scopes = Some(deser.read_string_list(member)?);
-234
+                }
                 Some(3) => {
                     builder.redirect_uris = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.redirect_uris = Some(deser.read_string_list(member)?);
-237
+                }
                 Some(4) => {
                     builder.grant_types = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.grant_types = Some(deser.read_string_list(member)?);
-240
+                }
                 Some(5) => {
                     builder.issuer_url = Some(deser.read_string(member)?);
-243
+                }
                 Some(6) => {
                     builder.entitled_application_arn = Some(deser.read_string(member)?);
-246
+                }
                 _ => {}
-248
+            }
             Ok(())
         })?;
         builder.client_name = builder.client_name.or(Some(String::new()));
         builder.client_type = builder.client_type.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-256
+    }
-257
+}
 impl RegisterClientInput {
     /// 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 RegisterClientInput {
     /// Creates a new builder-style object to manufacture [`RegisterClientInput`](crate::operation::register_client::RegisterClientInput).
     pub fn builder() -> crate::operation::register_client::builders::RegisterClientInputBuilder {
         crate::operation::register_client::builders::RegisterClientInputBuilder::default()
-273
+    }
-274
+}
-275
 /// A builder for [`RegisterClientInput`](crate::operation::register_client::RegisterClientInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct RegisterClientInputBuilder {
     pub(crate) client_name: ::std::option::Option<::std::string::String>,
     pub(crate) client_type: ::std::option::Option<::std::string::String>,
     pub(crate) scopes: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) redirect_uris: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) grant_types: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) issuer_url: ::std::option::Option<::std::string::String>,
     pub(crate) entitled_application_arn: ::std::option::Option<::std::string::String>,
-287
+}
 impl RegisterClientInputBuilder {
     /// <p>The friendly name of the client.</p>
     /// This field is required.
     pub fn client_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.client_name = ::std::option::Option::Some(input.into());
         self
-294
+    }
     /// <p>The friendly name of the client.</p>
     pub fn set_client_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.client_name = input;
         self

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/register_client/_register_client_output.rs

@@ -41,41 +213,273 @@

↥ Expand context

     /// <p>An endpoint that the client can use to create tokens.</p>
     pub fn token_endpoint(&self) -> ::std::option::Option<&str> {
         self.token_endpoint.as_deref()
-44
+    }
-45
+}
 impl ::std::fmt::Debug for RegisterClientOutput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("RegisterClientOutput");
         formatter.field("client_id", &self.client_id);
         formatter.field("client_secret", &"*** Sensitive Data Redacted ***");
         formatter.field("client_id_issued_at", &self.client_id_issued_at);
         formatter.field("client_secret_expires_at", &self.client_secret_expires_at);
         formatter.field("authorization_endpoint", &self.authorization_endpoint);
         formatter.field("token_endpoint", &self.token_endpoint);
         formatter.field("_request_id", &self._request_id);
         formatter.finish()
-57
+    }
-58
+}
 static REGISTERCLIENTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ssooidc.synthetic#RegisterClientOutput",

     "com.amazonaws.ssooidc.synthetic",
     "RegisterClientOutput",
 );
 static REGISTERCLIENTOUTPUT_MEMBER_CLIENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientOutput$clientId",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_id",
     "clientId",
 ,
 );
 static REGISTERCLIENTOUTPUT_MEMBER_CLIENT_SECRET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientOutput$clientSecret",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_secret",
     "clientSecret",
 ,
 );
 static REGISTERCLIENTOUTPUT_MEMBER_CLIENT_ID_ISSUED_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientOutput$clientIdIssuedAt",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "client_id_issued_at",
     "clientIdIssuedAt",
 ,
 );
 static REGISTERCLIENTOUTPUT_MEMBER_CLIENT_SECRET_EXPIRES_AT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientOutput$clientSecretExpiresAt",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "client_secret_expires_at",
     "clientSecretExpiresAt",
 ,
 );
 static REGISTERCLIENTOUTPUT_MEMBER_AUTHORIZATION_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientOutput$authorizationEndpoint",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "authorization_endpoint",
     "authorizationEndpoint",
 ,
 );
 static REGISTERCLIENTOUTPUT_MEMBER_TOKEN_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#RegisterClientOutput$tokenEndpoint",
         "com.amazonaws.ssooidc.synthetic",
         "RegisterClientOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "token_endpoint",
     "tokenEndpoint",
 ,
 );
 static REGISTERCLIENTOUTPUT_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 REGISTERCLIENTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     REGISTERCLIENTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &REGISTERCLIENTOUTPUT_MEMBER_CLIENT_ID,
         &REGISTERCLIENTOUTPUT_MEMBER_CLIENT_SECRET,
         &REGISTERCLIENTOUTPUT_MEMBER_CLIENT_ID_ISSUED_AT,
         &REGISTERCLIENTOUTPUT_MEMBER_CLIENT_SECRET_EXPIRES_AT,
         &REGISTERCLIENTOUTPUT_MEMBER_AUTHORIZATION_ENDPOINT,
         &REGISTERCLIENTOUTPUT_MEMBER_TOKEN_ENDPOINT,
         &REGISTERCLIENTOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl RegisterClientOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &REGISTERCLIENTOUTPUT_SCHEMA;
-147
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for RegisterClientOutput {
     #[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.client_id {
             ser.write_string(&REGISTERCLIENTOUTPUT_MEMBER_CLIENT_ID, val)?;
-156
+        }
         if let Some(ref val) = self.client_secret {
             ser.write_string(&REGISTERCLIENTOUTPUT_MEMBER_CLIENT_SECRET, val)?;
-159
+        }
-160
+        {
             let val = &self.client_id_issued_at;
             ser.write_long(&REGISTERCLIENTOUTPUT_MEMBER_CLIENT_ID_ISSUED_AT, *val)?;
-163
+        }
-164
+        {
             let val = &self.client_secret_expires_at;
             ser.write_long(&REGISTERCLIENTOUTPUT_MEMBER_CLIENT_SECRET_EXPIRES_AT, *val)?;
-167
+        }
         if let Some(ref val) = self.authorization_endpoint {
             ser.write_string(&REGISTERCLIENTOUTPUT_MEMBER_AUTHORIZATION_ENDPOINT, val)?;
-170
+        }
         if let Some(ref val) = self.token_endpoint {
             ser.write_string(&REGISTERCLIENTOUTPUT_MEMBER_TOKEN_ENDPOINT, val)?;
-173
+        }
         Ok(())
-175
+    }
-176
+}
 impl RegisterClientOutput {
     /// 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(&REGISTERCLIENTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.client_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.client_secret = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.client_id_issued_at = Some(deser.read_long(member)?);
-+
+                }
                 Some(3) => {
                     builder.client_secret_expires_at = Some(deser.read_long(member)?);
-+
+                }
                 Some(4) => {
                     builder.authorization_endpoint = Some(deser.read_string(member)?);
-+
+                }
                 Some(5) => {
                     builder.token_endpoint = Some(deser.read_string(member)?);
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl RegisterClientOutput {
     /// 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(&REGISTERCLIENTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&REGISTERCLIENTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.client_id = Some(deser.read_string(member)?);
-247
+                }
                 Some(1) => {
                     builder.client_secret = Some(deser.read_string(member)?);
-250
+                }
                 Some(2) => {
                     builder.client_id_issued_at = Some(deser.read_long(member)?);
-253
+                }

↧ Expand context

                 Some(3) => {
                     builder.client_secret_expires_at = Some(deser.read_long(member)?);
-256
+                }
                 Some(4) => {
                     builder.authorization_endpoint = Some(deser.read_string(member)?);
-259
+                }
                 Some(5) => {
                     builder.token_endpoint = Some(deser.read_string(member)?);
-262
+                }
                 _ => {}
-264
+            }
             Ok(())
         })?;
         Ok(builder.build())
-268
+    }
-269
+}
 impl ::aws_types::request_id::RequestId for RegisterClientOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-273
+    }

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/start_device_authorization.rs

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

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

↧ Expand context

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

@@ -108,114 +232,376 @@

↥ Expand context

         ));
-115
         ::std::option::Option::Some(cfg.freeze())
-117
+    }
-118
     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("StartDeviceAuthorization")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(StartDeviceAuthorizationEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::start_device_authorization::StartDeviceAuthorizationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::start_device_authorization::StartDeviceAuthorizationError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::start_device_authorization::StartDeviceAuthorizationError,
             >::new());
-136
         ::std::borrow::Cow::Owned(rcb)
-138
+    }
-139
+}
-140
 #[derive(Debug)]
 struct StartDeviceAuthorizationResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartDeviceAuthorizationResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_start_device_authorization::de_start_device_authorization_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_start_device_authorization::de_start_device_authorization_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::start_device_authorization::StartDeviceAuthorizationError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InternalServerException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::InternalServerException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidClientException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::InvalidClientException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidClientException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidClientException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InvalidRequestException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::InvalidRequestException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidRequestException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidRequestException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "SlowDownException" => crate::operation::start_device_authorization::StartDeviceAuthorizationError::SlowDownException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::SlowDownException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::SlowDownException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "UnauthorizedClientException" => {
                     crate::operation::start_device_authorization::StartDeviceAuthorizationError::UnauthorizedClientException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::UnauthorizedClientException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::UnauthorizedClientException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 _ => crate::operation::start_device_authorization::StartDeviceAuthorizationError::generic(generic),
             };
         crate::protocol_serde::type_erase_result(parse_result)
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, StartDeviceAuthorization::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::start_device_authorization::StartDeviceAuthorizationOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-325
+    }
-326
+}
 #[derive(Debug)]
 struct StartDeviceAuthorizationRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartDeviceAuthorizationRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::start_device_authorization::StartDeviceAuthorizationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::start_device_authorization::StartDeviceAuthorizationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/device_authorization").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_device_authorization::StartDeviceAuthorizationInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_start_device_authorization::ser_start_device_authorization_input(&input)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, StartDeviceAuthorization::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-347
+    }
-348
+}
 #[derive(Debug)]
 struct StartDeviceAuthorizationEndpointParamsInterceptor;
-351
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartDeviceAuthorizationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartDeviceAuthorizationEndpointParamsInterceptor"
-355
+    }
-356

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StartDeviceAuthorizationInput>()
             .ok_or("failed to downcast to StartDeviceAuthorizationInput")?;
-371
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/start_device_authorization/_start_device_authorization_input.rs

@@ -18,18 +165,180 @@

↥ Expand context

     /// <p>A secret string that is generated for the client. This value should come from the persisted result of the <code>RegisterClient</code> API operation.</p>
     pub fn client_secret(&self) -> ::std::option::Option<&str> {
         self.client_secret.as_deref()
-21
+    }
     /// <p>The URL for the Amazon Web Services access portal. For more information, see <a href="https://docs.aws.amazon.com/singlesignon/latest/userguide/using-the-portal.html">Using the Amazon Web Services access portal</a> in the <i>IAM Identity Center User Guide</i>.</p>
     pub fn start_url(&self) -> ::std::option::Option<&str> {
         self.start_url.as_deref()
-25
+    }
-26
+}
 impl ::std::fmt::Debug for StartDeviceAuthorizationInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("StartDeviceAuthorizationInput");
         formatter.field("client_id", &self.client_id);
         formatter.field("client_secret", &"*** Sensitive Data Redacted ***");
         formatter.field("start_url", &self.start_url);
         formatter.finish()
-34
+    }
-35
+}
 static STARTDEVICEAUTHORIZATIONINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationInput",

     "com.amazonaws.ssooidc.synthetic",
     "StartDeviceAuthorizationInput",
 );
 static STARTDEVICEAUTHORIZATIONINPUT_MEMBER_CLIENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationInput$clientId",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_id",
     "clientId",
 ,
 );
 static STARTDEVICEAUTHORIZATIONINPUT_MEMBER_CLIENT_SECRET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationInput$clientSecret",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "client_secret",
     "clientSecret",
 ,
 );
 static STARTDEVICEAUTHORIZATIONINPUT_MEMBER_START_URL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationInput$startUrl",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "start_url",
     "startUrl",
 ,
 );
 static STARTDEVICEAUTHORIZATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTDEVICEAUTHORIZATIONINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTDEVICEAUTHORIZATIONINPUT_MEMBER_CLIENT_ID,
         &STARTDEVICEAUTHORIZATIONINPUT_MEMBER_CLIENT_SECRET,
         &STARTDEVICEAUTHORIZATIONINPUT_MEMBER_START_URL,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/device_authorization", None));
 impl StartDeviceAuthorizationInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTDEVICEAUTHORIZATIONINPUT_SCHEMA;
-84
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartDeviceAuthorizationInput {
     #[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.client_id {
             ser.write_string(&STARTDEVICEAUTHORIZATIONINPUT_MEMBER_CLIENT_ID, val)?;
-93
+        }
         if let Some(ref val) = self.client_secret {
             ser.write_string(&STARTDEVICEAUTHORIZATIONINPUT_MEMBER_CLIENT_SECRET, val)?;
-96
+        }
         if let Some(ref val) = self.start_url {
             ser.write_string(&STARTDEVICEAUTHORIZATIONINPUT_MEMBER_START_URL, val)?;
-99
+        }
         Ok(())
-101
+    }
-102
+}
 impl StartDeviceAuthorizationInput {
     /// 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(&STARTDEVICEAUTHORIZATIONINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTDEVICEAUTHORIZATIONINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.client_id = Some(deser.read_string(member)?);
-121
+                }
                 Some(1) => {
                     builder.client_secret = Some(deser.read_string(member)?);
-124
+                }
                 Some(2) => {
                     builder.start_url = Some(deser.read_string(member)?);
-127
+                }
                 _ => {}
-129
+            }
             Ok(())
         })?;
         builder.client_id = builder.client_id.or(Some(String::new()));
         builder.client_secret = builder.client_secret.or(Some(String::new()));
         builder.start_url = builder.start_url.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-138
+    }
-139
+}
 impl StartDeviceAuthorizationInput {
     /// 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 StartDeviceAuthorizationInput {
     /// Creates a new builder-style object to manufacture [`StartDeviceAuthorizationInput`](crate::operation::start_device_authorization::StartDeviceAuthorizationInput).
     pub fn builder() -> crate::operation::start_device_authorization::builders::StartDeviceAuthorizationInputBuilder {
         crate::operation::start_device_authorization::builders::StartDeviceAuthorizationInputBuilder::default()
-155
+    }
-156
+}
-157
 /// A builder for [`StartDeviceAuthorizationInput`](crate::operation::start_device_authorization::StartDeviceAuthorizationInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct StartDeviceAuthorizationInputBuilder {
     pub(crate) client_id: ::std::option::Option<::std::string::String>,
     pub(crate) client_secret: ::std::option::Option<::std::string::String>,
     pub(crate) start_url: ::std::option::Option<::std::string::String>,
-165
+}
 impl StartDeviceAuthorizationInputBuilder {
     /// <p>The unique identifier string for the client that is registered with IAM Identity Center. This value should come from the persisted result of the <code>RegisterClient</code> API operation.</p>
     /// This field is required.
     pub fn client_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.client_id = ::std::option::Option::Some(input.into());
         self
-172
+    }
     /// <p>The unique identifier string for the client that is registered with IAM Identity Center. This value should come from the persisted result of the <code>RegisterClient</code> API operation.</p>
     pub fn set_client_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.client_id = input;
         self
-177
+    }
     /// <p>The unique identifier string for the client that is registered with IAM Identity Center. This value should come from the persisted result of the <code>RegisterClient</code> API operation.</p>
     pub fn get_client_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.client_id

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/start_device_authorization/_start_device_authorization_output.rs

@@ -28,28 +200,260 @@

↥ Expand context

-28
+    }
     /// <p>The URI of the verification page that takes the <code>userCode</code> to authorize the device.</p>
     pub fn verification_uri(&self) -> ::std::option::Option<&str> {
         self.verification_uri.as_deref()
-32
+    }
     /// <p>An alternate URL that the client can use to automatically launch a browser. This process skips the manual step in which the user visits the verification page and enters their code.</p>
     pub fn verification_uri_complete(&self) -> ::std::option::Option<&str> {
         self.verification_uri_complete.as_deref()
-36
+    }
     /// <p>Indicates the number of seconds in which the verification code will become invalid.</p>
     pub fn expires_in(&self) -> i32 {
         self.expires_in
-40
+    }
     /// <p>Indicates the number of seconds the client must wait between attempts when polling for a session.</p>
     pub fn interval(&self) -> i32 {
         self.interval
-44
+    }
-45
+}
 static STARTDEVICEAUTHORIZATIONOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationOutput",

     "com.amazonaws.ssooidc.synthetic",
     "StartDeviceAuthorizationOutput",
 );
 static STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_DEVICE_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationOutput$deviceCode",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "device_code",
     "deviceCode",
 ,
 );
 static STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_USER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationOutput$userCode",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "user_code",
     "userCode",
 ,
 );
 static STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_VERIFICATION_URI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationOutput$verificationUri",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "verification_uri",
     "verificationUri",
 ,
 );
 static STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_VERIFICATION_URI_COMPLETE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationOutput$verificationUriComplete",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "verification_uri_complete",
     "verificationUriComplete",
 ,
 );
 static STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_EXPIRES_IN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationOutput$expiresIn",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "expires_in",
     "expiresIn",
 ,
 );
 static STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_INTERVAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ssooidc.synthetic#StartDeviceAuthorizationOutput$interval",
         "com.amazonaws.ssooidc.synthetic",
         "StartDeviceAuthorizationOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "interval",
 ,
 );
 static STARTDEVICEAUTHORIZATIONOUTPUT_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 STARTDEVICEAUTHORIZATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     STARTDEVICEAUTHORIZATIONOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_DEVICE_CODE,
         &STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_USER_CODE,
         &STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_VERIFICATION_URI,
         &STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_VERIFICATION_URI_COMPLETE,
         &STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_EXPIRES_IN,
         &STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_INTERVAL,
         &STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl StartDeviceAuthorizationOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STARTDEVICEAUTHORIZATIONOUTPUT_SCHEMA;
-134
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for StartDeviceAuthorizationOutput {
     #[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.device_code {
             ser.write_string(&STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_DEVICE_CODE, val)?;
-143
+        }
         if let Some(ref val) = self.user_code {
             ser.write_string(&STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_USER_CODE, val)?;
-146
+        }
         if let Some(ref val) = self.verification_uri {
             ser.write_string(&STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_VERIFICATION_URI, val)?;
-149
+        }
         if let Some(ref val) = self.verification_uri_complete {
             ser.write_string(&STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_VERIFICATION_URI_COMPLETE, val)?;
-152
+        }
-153
+        {
             let val = &self.expires_in;
             ser.write_integer(&STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_EXPIRES_IN, *val)?;
-156
+        }
-157
+        {
             let val = &self.interval;
             ser.write_integer(&STARTDEVICEAUTHORIZATIONOUTPUT_MEMBER_INTERVAL, *val)?;
-160
+        }
         Ok(())
-162
+    }
-163
+}
 impl StartDeviceAuthorizationOutput {
     /// 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(&STARTDEVICEAUTHORIZATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.device_code = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.user_code = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.verification_uri = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.verification_uri_complete = Some(deser.read_string(member)?);
-+
+                }
                 Some(4) => {
                     builder.expires_in = Some(deser.read_integer(member)?);
-+
+                }
                 Some(5) => {
                     builder.interval = Some(deser.read_integer(member)?);
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl StartDeviceAuthorizationOutput {
     /// 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(&STARTDEVICEAUTHORIZATIONOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&STARTDEVICEAUTHORIZATIONOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.device_code = Some(deser.read_string(member)?);
-234
+                }
                 Some(1) => {
                     builder.user_code = Some(deser.read_string(member)?);
-237
+                }
                 Some(2) => {
                     builder.verification_uri = Some(deser.read_string(member)?);
-240
+                }

↧ Expand context

                 Some(3) => {
                     builder.verification_uri_complete = Some(deser.read_string(member)?);
-243
+                }
                 Some(4) => {
                     builder.expires_in = Some(deser.read_integer(member)?);
-246
+                }
                 Some(5) => {
                     builder.interval = Some(deser.read_integer(member)?);
-249
+                }
                 _ => {}
-251
+            }
             Ok(())
         })?;
         Ok(builder.build())
-255
+    }
-256
+}
 impl ::aws_types::request_id::RequestId for StartDeviceAuthorizationOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-260
+    }

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde.rs

@@ -1,1 +80,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn type_erase_result<O, E>(
     result: ::std::result::Result<O, E>,
 ) -> ::std::result::Result<
     ::aws_smithy_runtime_api::client::interceptors::context::Output,
     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
--
+>
 where
     O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
     E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
--
+{
     result
         .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
         .map_err(::std::convert::Into::into)
--
+}
--
 pub fn parse_http_error_metadata(
     _response_status: u16,
     response_headers: &::aws_smithy_runtime_api::http::Headers,
     response_body: &[u8],
 ) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     crate::json_errors::parse_error_metadata(response_body, response_headers)
-8
+}
--
 pub(crate) mod shape_create_token;
--
 pub(crate) mod shape_create_token_with_iam;
--
 pub(crate) mod shape_register_client;
--
 pub(crate) mod shape_start_device_authorization;
--
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
--
+    }
--
+}
--
 pub(crate) mod shape_access_denied_exception;
--
 pub(crate) mod shape_authorization_pending_exception;
--
 pub(crate) mod shape_create_token_input;
--
 pub(crate) mod shape_create_token_with_iam_input;
--
 pub(crate) mod shape_expired_token_exception;
--
 pub(crate) mod shape_internal_server_exception;
--
 pub(crate) mod shape_invalid_client_exception;
--
 pub(crate) mod shape_invalid_client_metadata_exception;
--
 pub(crate) mod shape_invalid_grant_exception;
--
 pub(crate) mod shape_invalid_redirect_uri_exception;
--
 pub(crate) mod shape_invalid_request_exception;
--
 pub(crate) mod shape_invalid_request_region_exception;
--
 pub(crate) mod shape_invalid_scope_exception;
--
 pub(crate) mod shape_register_client_input;
--
 pub(crate) mod shape_slow_down_exception;
--
 pub(crate) mod shape_start_device_authorization_input;
--
 pub(crate) mod shape_unauthorized_client_exception;
--
 pub(crate) mod shape_unsupported_grant_type_exception;
--
 pub(crate) mod shape_aws_additional_details;
--
 pub(crate) mod shape_scopes;

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_access_denied_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::AccessDeniedExceptionBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::AccessDeniedExceptionBuilder, ::aws_smithy_json::deserialize::error::DeserializeError> {
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "error" => {
                     builder = builder.set_error(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "reason" => {
                     builder = builder.set_reason(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| crate::types::AccessDeniedExceptionReason::from(u.as_ref())))
                             .transpose()?,
                     );
--
+                }
                 "error_description" => {
                     builder = builder.set_error_description(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "Message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) fn de_authorization_pending_exception_json_err(
     _value: &[u8],
     mut builder: crate::types::error::builders::AuthorizationPendingExceptionBuilder,
 ) -> ::std::result::Result<crate::types::error::builders::AuthorizationPendingExceptionBuilder, ::aws_smithy_json::deserialize::error::DeserializeError>
--
+{
     let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(_value)).peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
                 "error" => {
                     builder = builder.set_error(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "error_description" => {
                     builder = builder.set_error_description(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 "Message" => {
                     builder = builder.set_message(
                         ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                     );
--
+                }
                 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
             },
             other => {
                 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                     "expected object key or end object, found: {other:?}"
                 )))
--
+            }
--
+        }
--
+    }
     if tokens.next().is_some() {
         return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
             "found more JSON tokens after completing parsing",
         ));
--
+    }
     Ok(builder)
--
+}

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/create_token_with_iam/_create_token_with_iam_output.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/register_client.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/register_client/_register_client_input.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/register_client/_register_client_output.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/start_device_authorization.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/start_device_authorization/_start_device_authorization_input.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/operation/start_device_authorization/_start_device_authorization_output.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde/shape_access_denied_exception.rs

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/protocol_serde/shape_authorization_pending_exception.rs