AWS SDK

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/converse/_converse_output.rs

@@ -44,44 +225,287 @@

     pub fn trace(&self) -> ::std::option::Option<&crate::types::ConverseTrace> {
         self.trace.as_ref()
-46
+    }
     /// <p>Model performance settings for the request.</p>
     pub fn performance_config(&self) -> ::std::option::Option<&crate::types::PerformanceConfiguration> {
         self.performance_config.as_ref()
-50
+    }
-51
+}
 static CONVERSEOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.bedrockruntime.synthetic#ConverseOutput",
     "com.amazonaws.bedrockruntime.synthetic",
     "ConverseOutput",
 );
 static CONVERSEOUTPUT_MEMBER_OUTPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseOutput$output",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,

     "output",
 ,
 );
 static CONVERSEOUTPUT_MEMBER_STOP_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseOutput$stopReason",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "stop_reason",
     "stopReason",
 ,
 );
 static CONVERSEOUTPUT_MEMBER_USAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseOutput$usage",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "usage",
 ,
 );
 static CONVERSEOUTPUT_MEMBER_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseOutput$metrics",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "metrics",
 ,
 );
 static CONVERSEOUTPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseOutput$additionalModelResponseFields",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "additional_model_response_fields",
     "additionalModelResponseFields",
 ,
 );
 static CONVERSEOUTPUT_MEMBER_TRACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseOutput$trace",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "trace",
 ,
 );
 static CONVERSEOUTPUT_MEMBER_PERFORMANCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseOutput$performanceConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "performance_config",
     "performanceConfig",
 ,
 );
 static CONVERSEOUTPUT_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 CONVERSEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CONVERSEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CONVERSEOUTPUT_MEMBER_OUTPUT,
         &CONVERSEOUTPUT_MEMBER_STOP_REASON,
         &CONVERSEOUTPUT_MEMBER_USAGE,
         &CONVERSEOUTPUT_MEMBER_METRICS,
         &CONVERSEOUTPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELDS,
         &CONVERSEOUTPUT_MEMBER_TRACE,
         &CONVERSEOUTPUT_MEMBER_PERFORMANCE_CONFIG,
         &CONVERSEOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ConverseOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONVERSEOUTPUT_SCHEMA;
-151
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ConverseOutput {
     #[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.output {
             ser.write_null(&CONVERSEOUTPUT_MEMBER_OUTPUT)?;
             ser.write_struct(&CONVERSEOUTPUT_MEMBER_OUTPUT, val)?;
-160
+        }
-161
+        {
             let val = &self.stop_reason;
             ser.write_string(&CONVERSEOUTPUT_MEMBER_STOP_REASON, val.as_str())?;
-164
+        }
         if let Some(ref val) = self.usage {
             ser.write_struct(&CONVERSEOUTPUT_MEMBER_USAGE, val)?;
-167
+        }
         if let Some(ref val) = self.metrics {
             ser.write_struct(&CONVERSEOUTPUT_MEMBER_METRICS, val)?;
-170
+        }
         if let Some(ref val) = self.additional_model_response_fields {
             ser.write_document(&CONVERSEOUTPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELDS, val)?;
-173
+        }
         if let Some(ref val) = self.trace {
             ser.write_struct(&CONVERSEOUTPUT_MEMBER_TRACE, val)?;
-176
+        }
         if let Some(ref val) = self.performance_config {
             ser.write_struct(&CONVERSEOUTPUT_MEMBER_PERFORMANCE_CONFIG, val)?;
-179
+        }
         Ok(())
-181
+    }
-182
+}
 impl ConverseOutput {
     /// 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(&CONVERSEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONVERSEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.output = Some(crate::types::ConverseOutput::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder.stop_reason = Some(crate::types::StopReason::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(2) => {
                     builder.usage = Some(crate::types::TokenUsage::deserialize(deser)?);
-+
+                }
                 Some(3) => {
                     builder.metrics = Some(crate::types::ConverseMetrics::deserialize(deser)?);
-+
+                }
                 Some(4) => {
                     builder.additional_model_response_fields = Some(deser.read_document(member)?);
-+
+                }
                 Some(5) => {
                     builder.trace = Some(crate::types::ConverseTrace::deserialize(deser)?);
-+
+                }
                 Some(6) => {
                     builder.performance_config = Some(crate::types::PerformanceConfiguration::deserialize(deser)?);
-+
+                }
                 Some(7) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl ConverseOutput {
     /// 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(&CONVERSEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.output = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     });
                     builder.output = Some(crate::types::ConverseOutput::deserialize(deser)?);
-258
+                }
                 Some(1) => {
                     builder.stop_reason = Some(crate::types::StopReason::from(deser.read_string(member)?.as_str()));
-261
+                }
                 Some(2) => {
                     builder.usage = Some(crate::types::TokenUsage::deserialize(deser)?);
-264
+                }
                 Some(3) => {
                     builder.metrics = Some(crate::types::ConverseMetrics::deserialize(deser)?);
-267
+                }

↧ Expand context

                 Some(4) => {
                     builder.additional_model_response_fields = Some(deser.read_document(member)?);
-270
+                }
                 Some(5) => {
                     builder.trace = Some(crate::types::ConverseTrace::deserialize(deser)?);
-273
+                }
                 Some(6) => {
                     builder.performance_config = Some(crate::types::PerformanceConfiguration::deserialize(deser)?);
-276
+                }
                 _ => {}
-278
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-284
+    }
-285
+}
 impl ::aws_types::request_id::RequestId for ConverseOutput {
     fn request_id(&self) -> Option<&str> {

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/converse_stream.rs

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

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

@@ -135,139 +263,523 @@

↥ Expand context

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

-159
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-163
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_converse_stream::de_converse_stream_http_response(response),
         ))
-167
+    }
-168
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_converse_stream::de_converse_stream_http_error(
             response.status().as_u16(),
         let status = response.status().as_u16();
         let headers = response.headers();
         #[allow(unused_mut)]
         let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
             ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         })?;
         generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         let generic = generic_builder.build();
         let error_code = match generic.code() {
             ::std::option::Option::Some(code) => code,
             ::std::option::Option::None => {
                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                     ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::converse_stream::ConverseStreamError::unhandled(generic)),
                 ))
-+
+            }
         };
         let _error_message = generic.message().map(|msg| msg.to_owned());
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let err = match error_code {
             "AccessDeniedException" => crate::operation::converse_stream::ConverseStreamError::AccessDeniedException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::AccessDeniedException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "InternalServerException" => crate::operation::converse_stream::ConverseStreamError::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
             }),
             "ModelErrorException" => crate::operation::converse_stream::ConverseStreamError::ModelErrorException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ModelErrorException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ModelErrorException::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
             }),
             "ModelNotReadyException" => crate::operation::converse_stream::ConverseStreamError::ModelNotReadyException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ModelNotReadyException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ModelNotReadyException::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
             }),
             "ModelTimeoutException" => crate::operation::converse_stream::ConverseStreamError::ModelTimeoutException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ModelTimeoutException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ModelTimeoutException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ResourceNotFoundException" => crate::operation::converse_stream::ConverseStreamError::ResourceNotFoundException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ResourceNotFoundException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ServiceUnavailableException" => crate::operation::converse_stream::ConverseStreamError::ServiceUnavailableException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ServiceUnavailableException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ThrottlingException" => crate::operation::converse_stream::ConverseStreamError::ThrottlingException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ThrottlingException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ValidationException" => crate::operation::converse_stream::ConverseStreamError::ValidationException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ValidationException::deserialize_with_response(
                             &mut *deser,
                             response.headers(),
                             response.status().into(),
                             body,
-+
+                        )
                     }) {
                     ::std::result::Result::Ok(val) => val,
                     ::std::result::Result::Err(e) => {
                         return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                             ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                         ))
-+
+                    }
                 };
                 tmp.meta = generic;
                 if tmp.message.is_none() {
                     tmp.message = _error_message;
-+
+                }
                 tmp
             }),
             "ModelStreamErrorException" => crate::operation::converse_stream::ConverseStreamError::ModelStreamErrorException({
                 let mut tmp = match protocol
                     .deserialize_response(response, crate::types::error::ModelStreamErrorException::SCHEMA, _cfg)
                     .and_then(|mut deser| {
                         crate::types::error::ModelStreamErrorException::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::converse_stream::ConverseStreamError::generic(generic),
         };
         ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
             ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         ))
-442
+    }
-443
+}
 #[derive(Debug)]
 struct ConverseStreamRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ConverseStreamRequestSerializer {
     #[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::converse_stream::ConverseStreamInput>()
             .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::converse_stream::ConverseStreamInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.model_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("model_id", "cannot be empty or unset"))?;
                 let model_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if model_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "model_id",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, ConverseStream::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/model/{modelId}/converse-stream".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.model_id {
                     uri = uri.replace("{modelId}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-482
+                }
                 ::std::write!(output, "/model/{modelId}/converse-stream", modelId = model_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-484
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::converse_stream::ConverseStreamInput,
                 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_converse_stream::ser_converse_stream_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);
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, ConverseStream::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-493
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-494
+    }
-495
+}
 #[derive(Debug)]
 struct ConverseStreamEndpointParamsInterceptor;
-498
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ConverseStreamEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ConverseStreamEndpointParamsInterceptor"
-502
+    }
-503

↧ 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::<ConverseStreamInput>()
             .ok_or("failed to downcast to ConverseStreamInput")?;
-518
         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/bedrockruntime/src/operation/converse_stream/_converse_stream_input.rs

@@ -114,114 +490,478 @@

↥ Expand context

-114
+}
 impl ::std::fmt::Debug for ConverseStreamInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("ConverseStreamInput");
         formatter.field("model_id", &self.model_id);
         formatter.field("messages", &self.messages);
         formatter.field("system", &self.system);
         formatter.field("inference_config", &self.inference_config);
         formatter.field("tool_config", &self.tool_config);
         formatter.field("guardrail_config", &self.guardrail_config);
         formatter.field("additional_model_request_fields", &self.additional_model_request_fields);
         formatter.field("prompt_variables", &"*** Sensitive Data Redacted ***");
         formatter.field("additional_model_response_field_paths", &self.additional_model_response_field_paths);
         formatter.field("request_metadata", &"*** Sensitive Data Redacted ***");
         formatter.field("performance_config", &self.performance_config);
         formatter.finish()
-130
+    }
-131
+}
 static CONVERSESTREAMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput",

     "com.amazonaws.bedrockruntime.synthetic",
     "ConverseStreamInput",
 );
 static CONVERSESTREAMINPUT_MEMBER_MODEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$modelId",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "model_id",
     "modelId",
 ,
-146
+)
 .with_http_label();
 static CONVERSESTREAMINPUT_MEMBER_MESSAGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$messages",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "messages",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_SYSTEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$system",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "system",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_INFERENCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$inferenceConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "inference_config",
     "inferenceConfig",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_TOOL_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$toolConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "tool_config",
     "toolConfig",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_GUARDRAIL_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$guardrailConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "guardrail_config",
     "guardrailConfig",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_ADDITIONAL_MODEL_REQUEST_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$additionalModelRequestFields",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "additional_model_request_fields",
     "additionalModelRequestFields",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_PROMPT_VARIABLES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$promptVariables",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "prompt_variables",
     "promptVariables",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$additionalModelResponseFieldPaths",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "additional_model_response_field_paths",
     "additionalModelResponseFieldPaths",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_REQUEST_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$requestMetadata",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "request_metadata",
     "requestMetadata",
 ,
 );
 static CONVERSESTREAMINPUT_MEMBER_PERFORMANCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamInput$performanceConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "performance_config",
     "performanceConfig",
 ,
 );
 static CONVERSESTREAMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CONVERSESTREAMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CONVERSESTREAMINPUT_MEMBER_MODEL_ID,
         &CONVERSESTREAMINPUT_MEMBER_MESSAGES,
         &CONVERSESTREAMINPUT_MEMBER_SYSTEM,
         &CONVERSESTREAMINPUT_MEMBER_INFERENCE_CONFIG,
         &CONVERSESTREAMINPUT_MEMBER_TOOL_CONFIG,
         &CONVERSESTREAMINPUT_MEMBER_GUARDRAIL_CONFIG,
         &CONVERSESTREAMINPUT_MEMBER_ADDITIONAL_MODEL_REQUEST_FIELDS,
         &CONVERSESTREAMINPUT_MEMBER_PROMPT_VARIABLES,
         &CONVERSESTREAMINPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS,
         &CONVERSESTREAMINPUT_MEMBER_REQUEST_METADATA,
         &CONVERSESTREAMINPUT_MEMBER_PERFORMANCE_CONFIG,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/model/{modelId}/converse-stream",
     None,
 ));
 impl ConverseStreamInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONVERSESTREAMINPUT_SCHEMA;
-273
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ConverseStreamInput {
     #[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.model_id {
             ser.write_string(&CONVERSESTREAMINPUT_MEMBER_MODEL_ID, val)?;
-282
+        }
         if let Some(ref val) = self.messages {
             ser.write_list(
                 &CONVERSESTREAMINPUT_MEMBER_MESSAGES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Message::SCHEMA, item)?;
-289
+                    }
                     Ok(())
                 },
             )?;
-293
+        }
         if let Some(ref val) = self.system {
             ser.write_list(
                 &CONVERSESTREAMINPUT_MEMBER_SYSTEM,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_struct(crate::types::SystemContentBlock::SCHEMA, item)?;
-300
+                    }
                     Ok(())
                 },
             )?;
-304
+        }
         if let Some(ref val) = self.inference_config {
             ser.write_struct(&CONVERSESTREAMINPUT_MEMBER_INFERENCE_CONFIG, val)?;
-307
+        }
         if let Some(ref val) = self.tool_config {
             ser.write_struct(&CONVERSESTREAMINPUT_MEMBER_TOOL_CONFIG, val)?;
-310
+        }
         if let Some(ref val) = self.guardrail_config {
             ser.write_struct(&CONVERSESTREAMINPUT_MEMBER_GUARDRAIL_CONFIG, val)?;
-313
+        }
         if let Some(ref val) = self.additional_model_request_fields {
             ser.write_document(&CONVERSESTREAMINPUT_MEMBER_ADDITIONAL_MODEL_REQUEST_FIELDS, val)?;
-316
+        }
         if let Some(ref val) = self.prompt_variables {
             ser.write_map(
                 &CONVERSESTREAMINPUT_MEMBER_PROMPT_VARIABLES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::PromptVariableValues::SCHEMA, value)?;
-324
+                    }
                     Ok(())
                 },
             )?;
-328
+        }
         if let Some(ref val) = self.additional_model_response_field_paths {
             ser.write_list(
                 &CONVERSESTREAMINPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-335
+                    }
                     Ok(())
                 },
             )?;
-339
+        }
         if let Some(ref val) = self.request_metadata {
             ser.write_map(
                 &CONVERSESTREAMINPUT_MEMBER_REQUEST_METADATA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-347
+                    }
                     Ok(())
                 },
             )?;
-351
+        }
         if let Some(ref val) = self.performance_config {
             ser.write_struct(&CONVERSESTREAMINPUT_MEMBER_PERFORMANCE_CONFIG, val)?;
-354
+        }
         Ok(())
-356
+    }
-357
+}
 impl ConverseStreamInput {
     /// 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(&CONVERSESTREAMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONVERSESTREAMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.model_id = Some(deser.read_string(member)?);
-376
+                }
                 Some(1) => {
                     builder.messages = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Message::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Message::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-386
+                }
                 Some(2) => {
                     builder.system = 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(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SystemContentBlock::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-396
+                }
                 Some(3) => {
                     builder.inference_config = Some(crate::types::InferenceConfiguration::deserialize(deser)?);
-399
+                }
                 Some(4) => {
                     builder.tool_config = Some(crate::types::ToolConfiguration::deserialize(deser)?);
-402
+                }
                 Some(5) => {
                     builder.guardrail_config = Some(crate::types::GuardrailStreamConfiguration::deserialize(deser)?);
-405
+                }
                 Some(6) => {
                     builder.additional_model_request_fields = Some(deser.read_document(member)?);
-408
+                }
                 Some(7) => {
                     builder.prompt_variables = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::PromptVariableValues::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-418
+                }
                 Some(8) => {
                     builder.additional_model_response_field_paths = 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.additional_model_response_field_paths = Some(deser.read_string_list(member)?);
-421
+                }
                 Some(9) => {
                     builder.request_metadata = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.request_metadata = Some(deser.read_string_string_map(member)?);
-424
+                }
                 Some(10) => {
                     builder.performance_config = Some(crate::types::PerformanceConfiguration::deserialize(deser)?);
-427
+                }
                 _ => {}
-429
+            }
             Ok(())
         })?;
         builder.model_id = builder.model_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-436
+    }
-437
+}
 impl ConverseStreamInput {
     /// 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 ConverseStreamInput {
     /// Creates a new builder-style object to manufacture [`ConverseStreamInput`](crate::operation::converse_stream::ConverseStreamInput).
     pub fn builder() -> crate::operation::converse_stream::builders::ConverseStreamInputBuilder {
         crate::operation::converse_stream::builders::ConverseStreamInputBuilder::default()
-453
+    }
-454
+}
-455
 /// A builder for [`ConverseStreamInput`](crate::operation::converse_stream::ConverseStreamInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct ConverseStreamInputBuilder {
     pub(crate) model_id: ::std::option::Option<::std::string::String>,
     pub(crate) messages: ::std::option::Option<::std::vec::Vec<crate::types::Message>>,
     pub(crate) system: ::std::option::Option<::std::vec::Vec<crate::types::SystemContentBlock>>,
     pub(crate) inference_config: ::std::option::Option<crate::types::InferenceConfiguration>,
     pub(crate) tool_config: ::std::option::Option<crate::types::ToolConfiguration>,
     pub(crate) guardrail_config: ::std::option::Option<crate::types::GuardrailStreamConfiguration>,
     pub(crate) additional_model_request_fields: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) prompt_variables: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::PromptVariableValues>>,
     pub(crate) additional_model_response_field_paths: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) request_metadata: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) performance_config: ::std::option::Option<crate::types::PerformanceConfiguration>,
-471
+}
 impl ConverseStreamInputBuilder {
     /// <p>Specifies the model or throughput with which to run inference, or the prompt resource to use in inference. The value depends on the resource that you use:</p>
     /// <ul>
     /// <li>
     /// <p>If you use a base model, specify the model ID or its ARN. For a list of model IDs for base models, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html#model-ids-arns">Amazon Bedrock base model IDs (on-demand throughput)</a> in the Amazon Bedrock User Guide.</p></li>
     /// <li>
     /// <p>If you use an inference profile, specify the inference profile ID or its ARN. For a list of inference profile IDs, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference-support.html">Supported Regions and models for cross-region inference</a> in the Amazon Bedrock User Guide.</p></li>

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/converse_stream/_converse_stream_output.rs

@@ -4,4 +105,150 @@

↥ Expand context

 #[derive(::std::fmt::Debug)]
 pub struct ConverseStreamOutput {
     /// <p>The output stream that the model generated.</p>
     pub stream: crate::event_receiver::EventReceiver<crate::types::ConverseStreamOutput, crate::types::error::ConverseStreamOutputError>,
     _request_id: Option<String>,
-9
+}
 impl ConverseStreamOutput {
     /// <p>The output stream that the model generated.</p>
     pub fn stream(
         &self,
     ) -> &crate::event_receiver::EventReceiver<crate::types::ConverseStreamOutput, crate::types::error::ConverseStreamOutputError> {
         &self.stream
-16
+    }
-17
+}
 static CONVERSESTREAMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.bedrockruntime.synthetic#ConverseStreamOutput",
     "com.amazonaws.bedrockruntime.synthetic",
     "ConverseStreamOutput",
 );
 static CONVERSESTREAMOUTPUT_MEMBER_STREAM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(

     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseStreamOutput$stream",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseStreamOutput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "stream",
 ,
-32
+)
 .with_http_payload();
 static CONVERSESTREAMOUTPUT_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 CONVERSESTREAMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CONVERSESTREAMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&CONVERSESTREAMOUTPUT_MEMBER_STREAM],
     &[&CONVERSESTREAMOUTPUT_MEMBER_STREAM, &CONVERSESTREAMOUTPUT_MEMBER__REQUEST_ID],
 );
 impl ConverseStreamOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONVERSESTREAMOUTPUT_SCHEMA;
-49
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ConverseStreamOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
--
+        {
             let val = &self.stream;
             ser.write_null(&CONVERSESTREAMOUTPUT_MEMBER_STREAM)?;
--
+        }
         Ok(())
-57
+    }
-58
+}
 impl ConverseStreamOutput {
     /// 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(&CONVERSESTREAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize streaming union")
                     });
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl ConverseStreamOutput {
     /// 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(&CONVERSESTREAMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONVERSESTREAMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.stream = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                         todo!("deserialize streaming union")
                     });
-122
+                }
                 _ => {}
-124
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-130
+    }

↧ Expand context

-131
+}
 impl ::aws_types::request_id::RequestId for ConverseStreamOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-135
+    }
-136
+}
 impl ConverseStreamOutput {
     /// Creates a new builder-style object to manufacture [`ConverseStreamOutput`](crate::operation::converse_stream::ConverseStreamOutput).
     pub fn builder() -> crate::operation::converse_stream::builders::ConverseStreamOutputBuilder {
         crate::operation::converse_stream::builders::ConverseStreamOutputBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`ConverseStreamOutput`](crate::operation::converse_stream::ConverseStreamOutput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ConverseStreamOutputBuilder {
     pub(crate) stream: ::std::option::Option<
         crate::event_receiver::EventReceiver<crate::types::ConverseStreamOutput, crate::types::error::ConverseStreamOutputError>,
     >,

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/count_tokens.rs

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

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

@@ -118,122 +251,432 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("CountTokens")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(CountTokensEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::count_tokens::CountTokensError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::count_tokens::CountTokensError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::count_tokens::CountTokensError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct CountTokensResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CountTokensResponseDeserializer {
     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_count_tokens::de_count_tokens_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_count_tokens::de_count_tokens_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::count_tokens::CountTokensError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "AccessDeniedException" => crate::operation::count_tokens::CountTokensError::AccessDeniedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerException" => crate::operation::count_tokens::CountTokensError::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
                 }),
                 "ResourceNotFoundException" => crate::operation::count_tokens::CountTokensError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::count_tokens::CountTokensError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ThrottlingException" => crate::operation::count_tokens::CountTokensError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ValidationException" => crate::operation::count_tokens::CountTokensError::ValidationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::count_tokens::CountTokensError::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, CountTokens::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::count_tokens::CountTokensOutput::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))
-+
+        }
-351
+    }
-352
+}
 #[derive(Debug)]
 struct CountTokensRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CountTokensRequestSerializer {
     #[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::count_tokens::CountTokensInput>()
             .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::count_tokens::CountTokensInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.model_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("model_id", "cannot be empty or unset"))?;
                 let model_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if model_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "model_id",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, CountTokens::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/model/{modelId}/count-tokens".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.model_id {
                     uri = uri.replace("{modelId}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-391
+                }
                 ::std::write!(output, "/model/{modelId}/count-tokens", modelId = model_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-393
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::count_tokens::CountTokensInput,
                 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_count_tokens::ser_count_tokens_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);
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, CountTokens::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-402
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-403
+    }
-404
+}
 #[derive(Debug)]
 struct CountTokensEndpointParamsInterceptor;
-407
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CountTokensEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CountTokensEndpointParamsInterceptor"
-411
+    }
-412

↧ 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::<CountTokensInput>()
             .ok_or("failed to downcast to CountTokensInput")?;
-427
         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/bedrockruntime/src/operation/count_tokens/_count_tokens_input.rs

@@ -17,17 +148,158 @@

↥ Expand context

-17
+}
 impl CountTokensInput {
     /// <p>The unique identifier or ARN of the foundation model to use for token counting. Each model processes tokens differently, so the token count is specific to the model you specify.</p>
     pub fn model_id(&self) -> ::std::option::Option<&str> {
         self.model_id.as_deref()
-22
+    }
     /// <p>The input for which to count tokens. The structure of this parameter depends on whether you're counting tokens for an <code>InvokeModel</code> or <code>Converse</code> request:</p>
     /// <ul>
     /// <li>
     /// <p>For <code>InvokeModel</code> requests, provide the request body in the <code>invokeModel</code> field</p></li>
     /// <li>
     /// <p>For <code>Converse</code> requests, provide the messages and system content in the <code>converse</code> field</p></li>
     /// </ul>
     /// <p>The input format must be compatible with the model specified in the <code>modelId</code> parameter.</p>
     pub fn input(&self) -> ::std::option::Option<&crate::types::CountTokensInput> {
         self.input.as_ref()
-33
+    }
-34
+}
 static COUNTTOKENSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.bedrockruntime.synthetic#CountTokensInput",

     "com.amazonaws.bedrockruntime.synthetic",
     "CountTokensInput",
 );
 static COUNTTOKENSINPUT_MEMBER_MODEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#CountTokensInput$modelId",
         "com.amazonaws.bedrockruntime.synthetic",
         "CountTokensInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "model_id",
     "modelId",
 ,
-49
+)
 .with_http_label();
 static COUNTTOKENSINPUT_MEMBER_INPUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#CountTokensInput$input",
         "com.amazonaws.bedrockruntime.synthetic",
         "CountTokensInput",
     ),
     ::aws_smithy_schema::ShapeType::Union,
     "input",
 ,
 );
 static COUNTTOKENSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COUNTTOKENSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COUNTTOKENSINPUT_MEMBER_MODEL_ID, &COUNTTOKENSINPUT_MEMBER_INPUT],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/model/{modelId}/count-tokens", None));
 impl CountTokensInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COUNTTOKENSINPUT_SCHEMA;
-70
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CountTokensInput {
     #[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.model_id {
             ser.write_string(&COUNTTOKENSINPUT_MEMBER_MODEL_ID, val)?;
-79
+        }
         if let Some(ref val) = self.input {
             ser.write_null(&COUNTTOKENSINPUT_MEMBER_INPUT)?;
             ser.write_struct(&COUNTTOKENSINPUT_MEMBER_INPUT, val)?;
-82
+        }
         Ok(())
-84
+    }
-85
+}
 impl CountTokensInput {
     /// 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(&COUNTTOKENSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COUNTTOKENSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.model_id = Some(deser.read_string(member)?);
-104
+                }
                 Some(1) => {
                     builder.input = Some({
                         let _ = member;
                         todo!("deserialize aggregate")
                     });
                     builder.input = Some(crate::types::CountTokensInput::deserialize(deser)?);
-107
+                }
                 _ => {}
-109
+            }
             Ok(())
         })?;
         builder.model_id = builder.model_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-116
+    }
-117
+}
 impl CountTokensInput {
     /// 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 CountTokensInput {
     /// Creates a new builder-style object to manufacture [`CountTokensInput`](crate::operation::count_tokens::CountTokensInput).
     pub fn builder() -> crate::operation::count_tokens::builders::CountTokensInputBuilder {
         crate::operation::count_tokens::builders::CountTokensInputBuilder::default()
-133
+    }
-134
+}
-135
 /// A builder for [`CountTokensInput`](crate::operation::count_tokens::CountTokensInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct CountTokensInputBuilder {
     pub(crate) model_id: ::std::option::Option<::std::string::String>,
     pub(crate) input: ::std::option::Option<crate::types::CountTokensInput>,
-142
+}
 impl CountTokensInputBuilder {
     /// <p>The unique identifier or ARN of the foundation model to use for token counting. Each model processes tokens differently, so the token count is specific to the model you specify.</p>
     /// This field is required.
     pub fn model_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.model_id = ::std::option::Option::Some(input.into());
         self
-149
+    }
     /// <p>The unique identifier or ARN of the foundation model to use for token counting. Each model processes tokens differently, so the token count is specific to the model you specify.</p>
     pub fn set_model_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.model_id = input;
         self
-154
+    }
     /// <p>The unique identifier or ARN of the foundation model to use for token counting. Each model processes tokens differently, so the token count is specific to the model you specify.</p>
     pub fn get_model_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.model_id
-158
+    }

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/count_tokens/_count_tokens_output.rs

@@ -1,1 +97,144 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct CountTokensOutput {
     /// <p>The number of tokens in the provided input according to the specified model's tokenization rules. This count represents the number of input tokens that would be processed if the same input were sent to the model in an inference request. Use this value to estimate costs and ensure your inputs stay within model token limits.</p>
     pub input_tokens: i32,
     _request_id: Option<String>,
-9
+}
 impl CountTokensOutput {
     /// <p>The number of tokens in the provided input according to the specified model's tokenization rules. This count represents the number of input tokens that would be processed if the same input were sent to the model in an inference request. Use this value to estimate costs and ensure your inputs stay within model token limits.</p>
     pub fn input_tokens(&self) -> i32 {
         self.input_tokens
-14
+    }
-15
+}
 static COUNTTOKENSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.bedrockruntime.synthetic#CountTokensOutput",

     "com.amazonaws.bedrockruntime.synthetic",
     "CountTokensOutput",
 );
 static COUNTTOKENSOUTPUT_MEMBER_INPUT_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#CountTokensOutput$inputTokens",
         "com.amazonaws.bedrockruntime.synthetic",
         "CountTokensOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "input_tokens",
     "inputTokens",
 ,
 );
 static COUNTTOKENSOUTPUT_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 COUNTTOKENSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     COUNTTOKENSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&COUNTTOKENSOUTPUT_MEMBER_INPUT_TOKENS],
     &[&COUNTTOKENSOUTPUT_MEMBER_INPUT_TOKENS, &COUNTTOKENSOUTPUT_MEMBER__REQUEST_ID],
 );
 impl CountTokensOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COUNTTOKENSOUTPUT_SCHEMA;
-46
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for CountTokensOutput {
     #[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> {
-53
+        {
             let val = &self.input_tokens;
             ser.write_integer(&COUNTTOKENSOUTPUT_MEMBER_INPUT_TOKENS, *val)?;
-56
+        }
         Ok(())
-58
+    }
-59
+}
 impl CountTokensOutput {
     /// 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(&COUNTTOKENSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&COUNTTOKENSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.input_tokens = Some(deser.read_integer(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.input_tokens = builder.input_tokens.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl CountTokensOutput {
     /// 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(&COUNTTOKENSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.input_tokens = Some(deser.read_integer(member)?);
-118
+                }
                 _ => {}
-120
+            }
             Ok(())
         })?;
         builder
             .build()

↧ Expand context

             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-126
+    }
-127
+}
 impl ::aws_types::request_id::RequestId for CountTokensOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-131
+    }
-132
+}
 impl CountTokensOutput {
     /// Creates a new builder-style object to manufacture [`CountTokensOutput`](crate::operation::count_tokens::CountTokensOutput).
     pub fn builder() -> crate::operation::count_tokens::builders::CountTokensOutputBuilder {
         crate::operation::count_tokens::builders::CountTokensOutputBuilder::default()
-137
+    }
-138
+}
-139
 /// A builder for [`CountTokensOutput`](crate::operation::count_tokens::CountTokensOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct CountTokensOutputBuilder {
     pub(crate) input_tokens: ::std::option::Option<i32>,

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/get_async_invoke.rs

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

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

↧ Expand context

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

@@ -119,123 +248,389 @@

↥ Expand context

         });
-124
         ::std::option::Option::Some(cfg.freeze())
-126
+    }
-127
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("GetAsyncInvoke")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetAsyncInvokeEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_async_invoke::GetAsyncInvokeError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_async_invoke::GetAsyncInvokeError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_async_invoke::GetAsyncInvokeError,
             >::new());
-145
         ::std::borrow::Cow::Owned(rcb)
-147
+    }
-148
+}
-149
 #[derive(Debug)]
 struct GetAsyncInvokeResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAsyncInvokeResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_get_async_invoke::de_get_async_invoke_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_get_async_invoke::de_get_async_invoke_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::get_async_invoke::GetAsyncInvokeError::unhandled(
                             generic,
                         )),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "AccessDeniedException" => crate::operation::get_async_invoke::GetAsyncInvokeError::AccessDeniedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerException" => crate::operation::get_async_invoke::GetAsyncInvokeError::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
                 }),
                 "ThrottlingException" => crate::operation::get_async_invoke::GetAsyncInvokeError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::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
                 }),
                 "ValidationException" => crate::operation::get_async_invoke::GetAsyncInvokeError::ValidationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::get_async_invoke::GetAsyncInvokeError::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, GetAsyncInvoke::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::get_async_invoke::GetAsyncInvokeOutput::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))
-+
+        }
-308
+    }
-309
+}
 #[derive(Debug)]
 struct GetAsyncInvokeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAsyncInvokeRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::get_async_invoke::GetAsyncInvokeInput>()
             .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::get_async_invoke::GetAsyncInvokeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.invocation_arn;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("invocation_arn", "cannot be empty or unset"))?;
                 let invocation_arn = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if invocation_arn.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "invocation_arn",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, GetAsyncInvoke::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/async-invoke/{invocationArn}".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.invocation_arn {
                     uri = uri.replace("{invocationArn}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-348
+                }
                 ::std::write!(output, "/async-invoke/{invocationArn}", invocationArn = invocation_arn).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-350
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::get_async_invoke::GetAsyncInvokeInput,
                 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("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-351
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, GetAsyncInvoke::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-+
+        }
-360
+    }
-361
+}
 #[derive(Debug)]
 struct GetAsyncInvokeEndpointParamsInterceptor;
-364
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetAsyncInvokeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetAsyncInvokeEndpointParamsInterceptor"
-368
+    }
-369

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

AWS SDK

Files changed: