AWS SDK

rev. 52a747aa19d8f7ff1fb936dafeb9929959f2f20f

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-http/src/event_stream/receiver.rs

@@ -93,93 +188,203 @@

-93
+}
-94
 /// An error that occurs within an event stream receiver.
 #[derive(Debug)]
 pub struct ReceiverError {
     kind: ReceiverErrorKind,
-99
+}
-100
 impl fmt::Display for ReceiverError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             ReceiverErrorKind::UnexpectedEndOfStream => write!(f, "unexpected end of stream"),
-105
+        }
-106
+    }
-107
+}
-108
 impl StdError for ReceiverError {}
-110
 /// Receives Smithy-modeled messages out of an Event Stream.
 #[derive(Debug)]

 pub struct Receiver<T, E> {
     unmarshaller: Box<dyn UnmarshallMessage<Output = T, Error = E> + Send + Sync>,
     decoder: MessageFrameDecoder,
     buffer: RecvBuf,
     body: SdkBody,
     /// Event Stream has optional initial response frames an with `:message-type` of
     /// `initial-response`. If `try_recv_initial()` is called and the next message isn't an
     /// initial response, then the message will be stored in `buffered_message` so that it can
     /// be returned with the next call of `recv()`.
     buffered_message: Option<Message>,
     /// Stores initial-request or initial-response messages that were filtered out by `recv()`.
     /// These are only returned when `try_recv_initial()` is explicitly called.
     buffered_initial_message: Option<Message>,
     _phantom: PhantomData<E>,
-127
+}
-128
 // Used by `Receiver::try_recv_initial`, hence this enum is also doc hidden
 #[doc(hidden)]
 #[non_exhaustive]
 pub enum InitialMessageType {
     Request,
     Response,
-135
+}
-136
 impl InitialMessageType {
     fn as_str(&self) -> &'static str {
         match self {
             InitialMessageType::Request => "initial-request",
             InitialMessageType::Response => "initial-response",
-142
+        }
-143
+    }
-144
+}
-145
 impl<T, E> Receiver<T, E> {
     /// Creates a new `Receiver` with the given message unmarshaller and SDK body.
     pub fn new(
         unmarshaller: impl UnmarshallMessage<Output = T, Error = E> + Send + Sync + 'static,
         body: SdkBody,
     ) -> Self {
         Receiver {
             unmarshaller: Box::new(unmarshaller),
             decoder: MessageFrameDecoder::new(),
             buffer: RecvBuf::Empty,
             body,
             buffered_message: None,
             buffered_initial_message: None,
             _phantom: Default::default(),
-160
+        }
-161
+    }
-162
     /// Checks if a message is an initial-request or initial-response message.
     fn is_initial_message(message: &Message) -> bool {
         message
             .headers()
             .iter()
             .find(|h| h.name().as_str() == ":event-type")
             .and_then(|h| h.value().as_string().ok())
             .map(|s| s.as_str() == "initial-request" || s.as_str() == "initial-response")
             .unwrap_or(false)
-+
+    }
-+
     fn unmarshall(&self, message: Message) -> Result<Option<T>, SdkError<E, RawMessage>> {
         match self.unmarshaller.unmarshall(&message) {
             Ok(unmarshalled) => match unmarshalled {
                 UnmarshalledMessage::Event(event) => Ok(Some(event)),
                 UnmarshalledMessage::Error(err) => {
                     Err(SdkError::service_error(err, RawMessage::Decoded(message)))
-180
+                }
             },
             Err(err) => Err(SdkError::response_error(err, RawMessage::Decoded(message))),
-183
+        }

↧ Expand context

-184
+    }
-185
     async fn buffer_next_chunk(&mut self) -> Result<(), SdkError<E, RawMessage>> {
         use http_body_04x::Body;
-188
         if !self.buffer.is_eos() {
             let next_chunk = self
                 .body
                 .data()
                 .await
                 .transpose()
                 .map_err(|err| SdkError::dispatch_failure(ConnectorError::io(err)))?;
             let buffer = mem::replace(&mut self.buffer, RecvBuf::Empty);
             if let Some(chunk) = next_chunk {
                 self.buffer = buffer.with_partial(chunk);
             } else {
                 self.buffer = buffer.ended();
-201
+            }
-202
+        }
         Ok(())

@@ -213,228 +329,366 @@

↥ Expand context

             trace!(remaining_data = ?self.buffer, "data left over in the event stream response stream");
             let buf = self.buffer.buffered();
             return Err(SdkError::response_error(
                 ReceiverError {
                     kind: ReceiverErrorKind::UnexpectedEndOfStream,
                 },
                 RawMessage::invalid(Some(buf.copy_to_bytes(buf.remaining()))),
             ));
-236
+        }
         Ok(None)
-238
+    }
-239
     /// Tries to receive the initial response message that has `:event-type` of a given `message_type`.
     /// If a different event type is received, then it is buffered and `Ok(None)` is returned.
     #[doc(hidden)]
     pub async fn try_recv_initial(
         &mut self,
         message_type: InitialMessageType,
     ) -> Result<Option<Message>, SdkError<E, RawMessage>> {
         self.try_recv_initial_with_preprocessor(message_type, |msg| Ok((msg, ())))

             .await
             .map(|opt| opt.map(|(msg, _)| msg))
-250
+    }
-251
     /// Tries to receive the initial response message with preprocessing support.
     ///
     /// The preprocessor function can transform the raw message (e.g., unwrap envelopes)
     /// and return metadata alongside the transformed message. If the transformed message
     /// matches the expected `message_type`, both the message and metadata are returned.
     /// Otherwise, the transformed message is buffered and `Ok(None)` is returned.
     ///
     /// This method will block waiting for a message if no initial message has been buffered yet.
     #[doc(hidden)]
     pub async fn try_recv_initial_with_preprocessor<F, M>(
         &mut self,
         message_type: InitialMessageType,
         preprocessor: F,
     ) -> Result<Option<(Message, M)>, SdkError<E, RawMessage>>
     where
         F: FnOnce(Message) -> Result<(Message, M), ResponseError<RawMessage>>,
-268
+    {
         if let Some(message) = self.next_message().await? {
             let (processed_message, metadata) =
                 preprocessor(message.clone()).map_err(|err| SdkError::ResponseError(err))?;
--
             if let Some(event_type) = processed_message
                 .headers()
                 .iter()
                 .find(|h| h.name().as_str() == ":event-type")
         // Check if we already have a buffered initial message from recv()
         let message = if let Some(buffered) = self.buffered_initial_message.take() {
             buffered
         } else {
             // Otherwise, block waiting for the next message
             match self.next_message().await? {
                 Some(msg) => msg,
                 None => return Ok(None),
-+
+            }
         };
-+
         let (processed_message, metadata) =
             preprocessor(message.clone()).map_err(|err| SdkError::ResponseError(err))?;
-+
         if let Some(event_type) = processed_message
             .headers()
             .iter()
             .find(|h| h.name().as_str() == ":event-type")
-+
+        {
             if event_type
                 .value()
                 .as_string()
                 .ok()
                 .map(|s| s.as_str() == message_type.as_str())
                 .unwrap_or(false)
-294
+            {
                 if event_type
                     .value()
                     .as_string()
                     .map(|s| s.as_str() == message_type.as_str())
                     .unwrap_or(false)
--
+                {
                     return Ok(Some((processed_message, metadata)));
--
+                }
                 return Ok(Some((processed_message, metadata)));
-296
+            }
             // Buffer the processed message so that it can be returned by the next call to `recv()`
             self.buffered_message = Some(message);
-297
+        }
         // Buffer the original message so that it can be returned by the next call to `recv()`
         self.buffered_message = Some(message);
         Ok(None)
-301
+    }
-302
     /// Asynchronously tries to receive a message from the stream. If the stream has ended,
     /// it returns an `Ok(None)`. If there is a transport layer error, it will return
     /// `Err(SdkError::DispatchFailure)`. Service-modeled errors will be a part of the returned
     /// messages.
     ///
     /// This method filters out initial-request and initial-response messages. Those messages
     /// are only returned when `try_recv_initial()` is explicitly called.
     pub async fn recv(&mut self) -> Result<Option<T>, SdkError<E, RawMessage>> {
         if let Some(buffered) = self.buffered_message.take() {
             return match self.unmarshall(buffered) {
                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
         loop {
             if let Some(buffered) = self.buffered_message.take() {
                 return match self.unmarshall(buffered) {
                     Ok(message) => Ok(message),
                     Err(error) => {
                         self.buffer = RecvBuf::Terminated;
                         Err(error)
-+
+                    }
                 };
-+
+            }
             if let Some(message) = self.next_message().await? {
                 // Filter out initial messages - store them separately
                 if Self::is_initial_message(&message) {
                     self.buffered_initial_message = Some(message);
                     continue;
-326
+                }
             };
--
+        }
         if let Some(message) = self.next_message().await? {
             match self.unmarshall(message) {
                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
                 match self.unmarshall(message) {
                     Ok(message) => return Ok(message),
                     Err(error) => {
                         self.buffer = RecvBuf::Terminated;
                         return Err(error);
-+
+                    }
-333
+                }
             } else {
                 return Ok(None);
-336
+            }
         } else {
             Ok(None)
-337
+        }
-338
+    }
-339
+}
-340
 #[cfg(test)]
 mod tests {
     use super::{InitialMessageType, Receiver, UnmarshallMessage};
     use aws_smithy_eventstream::error::Error as EventStreamError;
     use aws_smithy_eventstream::frame::{write_message_to, UnmarshalledMessage};
     use aws_smithy_runtime_api::client::result::SdkError;

↧ Expand context

     use aws_smithy_types::body::SdkBody;
     use aws_smithy_types::event_stream::{Header, HeaderValue, Message};
     use bytes::Bytes;
     use hyper::body::Body;
     use std::error::Error as StdError;
     use std::io::{Error as IOError, ErrorKind};
-353
     fn encode_initial_response() -> Bytes {
         let mut buffer = Vec::new();
         let message = Message::new(Bytes::new())
             .add_header(Header::new(
                 ":message-type",
                 HeaderValue::String("event".into()),
             ))
             .add_header(Header::new(
                 ":event-type",
                 HeaderValue::String("initial-response".into()),
             ));
         write_message_to(&message, &mut buffer).unwrap();
         buffer.into()

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-legacy-http/src/event_stream/receiver.rs

@@ -1,1 +39,39 @@

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 use aws_smithy_eventstream::frame::{
     DecodedFrame, MessageFrameDecoder, UnmarshallMessage, UnmarshalledMessage,
 };
 use aws_smithy_runtime_api::client::result::{ConnectorError, SdkError};
 use aws_smithy_runtime_api::client::result::{ConnectorError, ResponseError, SdkError};
 use aws_smithy_types::body::SdkBody;
 use aws_smithy_types::event_stream::{Message, RawMessage};
 use bytes::Buf;
 use bytes::Bytes;
 use bytes_utils::SegmentedBuf;
 use std::error::Error as StdError;
 use std::fmt;
 use std::marker::PhantomData;
 use std::mem;
 use tracing::trace;

↧ Expand context

-20
 /// Wrapper around SegmentedBuf that tracks the state of the stream.
 #[derive(Debug)]
 enum RecvBuf {
     /// Nothing has been buffered yet.
     Empty,
     /// Some data has been buffered.
     /// The SegmentedBuf will automatically purge when it reads off the end of a chunk boundary.
     Partial(SegmentedBuf<Bytes>),
     /// The end of the stream has been reached, but there may still be some buffered data.
     EosPartial(SegmentedBuf<Bytes>),
     /// An exception terminated this stream.
     Terminated,
-33
+}
-34
 impl RecvBuf {
     /// Returns true if there's more buffered data.
     fn has_data(&self) -> bool {
         match self {
             RecvBuf::Empty | RecvBuf::Terminated => false,

@@ -93,93 +188,203 @@

↥ Expand context

-93
+}
-94
 /// An error that occurs within an event stream receiver.
 #[derive(Debug)]
 pub struct ReceiverError {
     kind: ReceiverErrorKind,
-99
+}
-100
 impl fmt::Display for ReceiverError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             ReceiverErrorKind::UnexpectedEndOfStream => write!(f, "unexpected end of stream"),
-105
+        }
-106
+    }
-107
+}
-108
 impl StdError for ReceiverError {}
-110
 /// Receives Smithy-modeled messages out of an Event Stream.
 #[derive(Debug)]

 pub struct Receiver<T, E> {
     unmarshaller: Box<dyn UnmarshallMessage<Output = T, Error = E> + Send + Sync>,
     decoder: MessageFrameDecoder,
     buffer: RecvBuf,
     body: SdkBody,
     /// Event Stream has optional initial response frames an with `:message-type` of
     /// `initial-response`. If `try_recv_initial()` is called and the next message isn't an
     /// initial response, then the message will be stored in `buffered_message` so that it can
     /// be returned with the next call of `recv()`.
     buffered_message: Option<Message>,
     /// Stores initial-request or initial-response messages that were filtered out by `recv()`.
     /// These are only returned when `try_recv_initial()` is explicitly called.
     buffered_initial_message: Option<Message>,
     _phantom: PhantomData<E>,
-127
+}
-128
 // Used by `Receiver::try_recv_initial`, hence this enum is also doc hidden
 #[doc(hidden)]
 #[non_exhaustive]
 pub enum InitialMessageType {
     Request,
     Response,
-135
+}
-136
 impl InitialMessageType {
     fn as_str(&self) -> &'static str {
         match self {
             InitialMessageType::Request => "initial-request",
             InitialMessageType::Response => "initial-response",
-142
+        }
-143
+    }
-144
+}
-145
 impl<T, E> Receiver<T, E> {
     /// Creates a new `Receiver` with the given message unmarshaller and SDK body.
     pub fn new(
         unmarshaller: impl UnmarshallMessage<Output = T, Error = E> + Send + Sync + 'static,
         body: SdkBody,
     ) -> Self {
         Receiver {
             unmarshaller: Box::new(unmarshaller),
             decoder: MessageFrameDecoder::new(),
             buffer: RecvBuf::Empty,
             body,
             buffered_message: None,
             buffered_initial_message: None,
             _phantom: Default::default(),
-160
+        }
-161
+    }
-162
     /// Checks if a message is an initial-request or initial-response message.
     fn is_initial_message(message: &Message) -> bool {
         message
             .headers()
             .iter()
             .find(|h| h.name().as_str() == ":event-type")
             .and_then(|h| h.value().as_string().ok())
             .map(|s| s.as_str() == "initial-request" || s.as_str() == "initial-response")
             .unwrap_or(false)
-+
+    }
-+
     fn unmarshall(&self, message: Message) -> Result<Option<T>, SdkError<E, RawMessage>> {
         match self.unmarshaller.unmarshall(&message) {
             Ok(unmarshalled) => match unmarshalled {
                 UnmarshalledMessage::Event(event) => Ok(Some(event)),
                 UnmarshalledMessage::Error(err) => {
                     Err(SdkError::service_error(err, RawMessage::Decoded(message)))
-180
+                }
             },
             Err(err) => Err(SdkError::response_error(err, RawMessage::Decoded(message))),
-183
+        }

↧ Expand context

-184
+    }
-185
     async fn buffer_next_chunk(&mut self) -> Result<(), SdkError<E, RawMessage>> {
         use http_body_04x::Body;
-188
         if !self.buffer.is_eos() {
             let next_chunk = self
                 .body
                 .data()
                 .await
                 .transpose()
                 .map_err(|err| SdkError::dispatch_failure(ConnectorError::io(err)))?;
             let buffer = mem::replace(&mut self.buffer, RecvBuf::Empty);
             if let Some(chunk) = next_chunk {
                 self.buffer = buffer.with_partial(chunk);
             } else {
                 self.buffer = buffer.ended();
-201
+            }
-202
+        }
         Ok(())

@@ -202,217 +306,366 @@

↥ Expand context

-217
+                        )
                     })?
-219
+                {
                     trace!(message = ?message, "received complete event stream message");
                     return Ok(Some(message));
-222
+                }
-223
+            }
-224
             self.buffer_next_chunk().await?;
-226
+        }
         if self.buffer.has_data() {
             trace!(remaining_data = ?self.buffer, "data left over in the event stream response stream");
             let buf = self.buffer.buffered();
             return Err(SdkError::response_error(
                 ReceiverError {
                     kind: ReceiverErrorKind::UnexpectedEndOfStream,
                 },
                 RawMessage::invalid(Some(buf.copy_to_bytes(buf.remaining()))),
             ));
-236
+        }

         Ok(None)
-238
+    }
-239
     /// Tries to receive the initial response message that has `:event-type` of a given `message_type`.
     /// If a different event type is received, then it is buffered and `Ok(None)` is returned.
     #[doc(hidden)]
     pub async fn try_recv_initial(
         &mut self,
         message_type: InitialMessageType,
     ) -> Result<Option<Message>, SdkError<E, RawMessage>> {
         if let Some(message) = self.next_message().await? {
             if let Some(event_type) = message
                 .headers()
                 .iter()
                 .find(|h| h.name().as_str() == ":event-type")
         self.try_recv_initial_with_preprocessor(message_type, |msg| Ok((msg, ())))
             .await
             .map(|opt| opt.map(|(msg, _)| msg))
-+
+    }
-+
     /// Tries to receive the initial response message with preprocessing support.
     ///
     /// The preprocessor function can transform the raw message (e.g., unwrap envelopes)
     /// and return metadata alongside the transformed message. If the transformed message
     /// matches the expected `message_type`, both the message and metadata are returned.
     /// Otherwise, the transformed message is buffered and `Ok(None)` is returned.
     ///
     /// This method will block waiting for a message if no initial message has been buffered yet.
     #[doc(hidden)]
     pub async fn try_recv_initial_with_preprocessor<F, M>(
         &mut self,
         message_type: InitialMessageType,
         preprocessor: F,
     ) -> Result<Option<(Message, M)>, SdkError<E, RawMessage>>
     where
         F: FnOnce(Message) -> Result<(Message, M), ResponseError<RawMessage>>,
-+
+    {
         // Check if we already have a buffered initial message from recv()
         let message = if let Some(buffered) = self.buffered_initial_message.take() {
             buffered
         } else {
             // Otherwise, block waiting for the next message
             match self.next_message().await? {
                 Some(msg) => msg,
                 None => return Ok(None),
-+
+            }
         };
-+
         let (processed_message, metadata) =
             preprocessor(message.clone()).map_err(|err| SdkError::ResponseError(err))?;
-+
         if let Some(event_type) = processed_message
             .headers()
             .iter()
             .find(|h| h.name().as_str() == ":event-type")
-+
+        {
             if event_type
                 .value()
                 .as_string()
                 .ok()
                 .map(|s| s.as_str() == message_type.as_str())
                 .unwrap_or(false)
-294
+            {
                 if event_type
                     .value()
                     .as_string()
                     .map(|s| s.as_str() == message_type.as_str())
                     .unwrap_or(false)
--
+                {
                     return Ok(Some(message));
--
+                }
                 return Ok(Some((processed_message, metadata)));
-296
+            }
             // Buffer the message so that it can be returned by the next call to `recv()`
             self.buffered_message = Some(message);
-297
+        }
         // Buffer the original message so that it can be returned by the next call to `recv()`
         self.buffered_message = Some(message);
         Ok(None)
-301
+    }
-302
     /// Asynchronously tries to receive a message from the stream. If the stream has ended,
     /// it returns an `Ok(None)`. If there is a transport layer error, it will return
     /// `Err(SdkError::DispatchFailure)`. Service-modeled errors will be a part of the returned
     /// messages.
     ///
     /// This method filters out initial-request and initial-response messages. Those messages
     /// are only returned when `try_recv_initial()` is explicitly called.
     pub async fn recv(&mut self) -> Result<Option<T>, SdkError<E, RawMessage>> {
         if let Some(buffered) = self.buffered_message.take() {
             return match self.unmarshall(buffered) {
                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
         loop {
             if let Some(buffered) = self.buffered_message.take() {
                 return match self.unmarshall(buffered) {
                     Ok(message) => Ok(message),
                     Err(error) => {
                         self.buffer = RecvBuf::Terminated;
                         Err(error)
-+
+                    }
                 };
-+
+            }
             if let Some(message) = self.next_message().await? {
                 // Filter out initial messages - store them separately
                 if Self::is_initial_message(&message) {
                     self.buffered_initial_message = Some(message);
                     continue;
-326
+                }
             };
--
+        }
         if let Some(message) = self.next_message().await? {
             match self.unmarshall(message) {
                 Ok(message) => Ok(message),
                 Err(error) => {
                     self.buffer = RecvBuf::Terminated;
                     Err(error)
                 match self.unmarshall(message) {
                     Ok(message) => return Ok(message),
                     Err(error) => {
                         self.buffer = RecvBuf::Terminated;
                         return Err(error);
-+
+                    }
-333
+                }
             } else {
                 return Ok(None);
-336
+            }
         } else {
             Ok(None)
-337
+        }
-338
+    }
-339
+}
-340
 #[cfg(test)]
 mod tests {
     use super::{InitialMessageType, Receiver, UnmarshallMessage};
     use aws_smithy_eventstream::error::Error as EventStreamError;
     use aws_smithy_eventstream::frame::{write_message_to, UnmarshalledMessage};
     use aws_smithy_runtime_api::client::result::SdkError;

↧ Expand context

     use aws_smithy_types::body::SdkBody;
     use aws_smithy_types::event_stream::{Header, HeaderValue, Message};
     use bytes::Bytes;
     use hyper::body::Body;
     use std::error::Error as StdError;
     use std::io::{Error as IOError, ErrorKind};
-353
     fn encode_initial_response() -> Bytes {
         let mut buffer = Vec::new();
         let message = Message::new(Bytes::new())
             .add_header(Header::new(
                 ":message-type",
                 HeaderValue::String("event".into()),
             ))
             .add_header(Header::new(
                 ":event-type",
                 HeaderValue::String("initial-response".into()),
             ));
         write_message_to(&message, &mut buffer).unwrap();
         buffer.into()

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

@@ -71,71 +161,133 @@

↥ Expand context

     /// Access the ConverseStream as a reference.
     pub fn as_input(&self) -> &crate::operation::converse_stream::builders::ConverseStreamInputBuilder {
         &self.inner
-74
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::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,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::converse_stream::ConverseStream::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::converse_stream::ConverseStream::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::converse_stream::ConverseStream::orchestrate(&runtime_plugins, input).await?;
-102
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::converse_stream::ConverseStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.stream.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-104
+    }
-105
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::converse_stream::ConverseStreamOutput,
         crate::operation::converse_stream::ConverseStreamError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-115
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-119
+    }
-120
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-124
+    }
     /// <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>
     /// <li>
     /// <p>If you use a provisioned model, specify the ARN of the Provisioned Throughput. For more information, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/prov-thru-use.html">Run inference using a Provisioned Throughput</a> in the Amazon Bedrock User Guide.</p></li>
     /// <li>

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

@@ -60,60 +152,124 @@

↥ Expand context

     /// Access the InvokeModelWithBidirectionalStream as a reference.
     pub fn as_input(&self) -> &crate::operation::invoke_model_with_bidirectional_stream::builders::InvokeModelWithBidirectionalStreamInputBuilder {
         &self.inner
-63
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStreamOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStream::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output =
         let output =
             crate::operation::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStream::orchestrate(&runtime_plugins, input)
                 .await?;
-93
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.body.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-95
+    }
-96
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStreamOutput,
         crate::operation::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStreamError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-106
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-110
+    }
-111
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-115
+    }
     /// <p>The model ID or ARN of the model ID to use. Currently, only <code>amazon.nova-sonic-v1:0</code> is supported.</p>
     pub fn model_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.inner = self.inner.model_id(input.into());
         self
-120
+    }
     /// <p>The model ID or ARN of the model ID to use. Currently, only <code>amazon.nova-sonic-v1:0</code> is supported.</p>
     pub fn set_model_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.inner = self.inner.set_model_id(input);
         self

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

@@ -67,67 +158,129 @@

↥ Expand context

     /// Access the InvokeModelWithResponseStream as a reference.
     pub fn as_input(&self) -> &crate::operation::invoke_model_with_response_stream::builders::InvokeModelWithResponseStreamInputBuilder {
         &self.inner
-70
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStream::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output =
             crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStream::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStream::orchestrate(&runtime_plugins, input).await?;
-98
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.body.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-100
+    }
-101
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamOutput,
         crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-111
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-115
+    }
-116
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-120
+    }
     /// <p>The prompt and inference parameters in the format specified in the <code>contentType</code> in the header. You must provide the body in JSON format. To see the format and content of the request and response bodies for different models, refer to <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html">Inference parameters</a>. For more information, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/api-methods-run.html">Run inference</a> in the Bedrock User Guide.</p>
     pub fn body(mut self, input: ::aws_smithy_types::Blob) -> Self {
         self.inner = self.inner.body(input);
         self
-125
+    }
     /// <p>The prompt and inference parameters in the format specified in the <code>contentType</code> in the header. You must provide the body in JSON format. To see the format and content of the request and response bodies for different models, refer to <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html">Inference parameters</a>. For more information, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/api-methods-run.html">Run inference</a> in the Bedrock User Guide.</p>
     pub fn set_body(mut self, input: ::std::option::Option<::aws_smithy_types::Blob>) -> Self {
         self.inner = self.inner.set_body(input);
         self

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/get_log_object/builders.rs

@@ -65,65 +155,127 @@

↥ Expand context

     /// Access the GetLogObject as a reference.
     pub fn as_input(&self) -> &crate::operation::get_log_object::builders::GetLogObjectInputBuilder {
         &self.inner
-68
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::get_log_object::GetLogObjectOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_log_object::GetLogObjectError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::get_log_object::GetLogObject::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::get_log_object::GetLogObject::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::get_log_object::GetLogObject::orchestrate(&runtime_plugins, input).await?;
-96
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_log_object::GetLogObjectError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.field_stream.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-98
+    }
-99
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::get_log_object::GetLogObjectOutput,
         crate::operation::get_log_object::GetLogObjectError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-109
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-113
+    }
-114
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-118
+    }
     /// <p>A boolean flag that indicates whether to unmask sensitive log data. When set to true, any masked or redacted data in the log object will be displayed in its original form. Default is false.</p>
     pub fn unmask(mut self, input: bool) -> Self {
         self.inner = self.inner.unmask(input);
         self
-123
+    }
     /// <p>A boolean flag that indicates whether to unmask sensitive log data. When set to true, any masked or redacted data in the log object will be displayed in its original form. Default is false.</p>
     pub fn set_unmask(mut self, input: ::std::option::Option<bool>) -> Self {
         self.inner = self.inner.set_unmask(input);
         self

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/start_live_tail/builders.rs

@@ -85,85 +175,147 @@

↥ Expand context

     /// Access the StartLiveTail as a reference.
     pub fn as_input(&self) -> &crate::operation::start_live_tail::builders::StartLiveTailInputBuilder {
         &self.inner
-88
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::start_live_tail::StartLiveTailOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_live_tail::StartLiveTailError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::start_live_tail::StartLiveTail::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::start_live_tail::StartLiveTail::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::start_live_tail::StartLiveTail::orchestrate(&runtime_plugins, input).await?;
-116
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_live_tail::StartLiveTailError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.response_stream.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-118
+    }
-119
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::start_live_tail::StartLiveTailOutput,
         crate::operation::start_live_tail::StartLiveTailError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-129
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-133
+    }
-134
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-138
+    }
     ///
     /// Appends an item to `logGroupIdentifiers`.
     ///
     /// To override the contents of this collection use [`set_log_group_identifiers`](Self::set_log_group_identifiers).
     ///
     /// <p>An array where each item in the array is a log group to include in the Live Tail session.</p>
     /// <p>Specify each log group by its ARN.</p>
     /// <p>If you specify an ARN, the ARN can't end with an asterisk (*).</p><note>
     /// <p>You can include up to 10 log groups.</p>

tmp-codegen-diff/aws-sdk/sdk/lambda/src/operation/invoke_with_response_stream/builders.rs

@@ -60,60 +150,122 @@

↥ Expand context

     /// Access the InvokeWithResponseStream as a reference.
     pub fn as_input(&self) -> &crate::operation::invoke_with_response_stream::builders::InvokeWithResponseStreamInputBuilder {
         &self.inner
-63
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::invoke_with_response_stream::InvokeWithResponseStreamOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::invoke_with_response_stream::InvokeWithResponseStream::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::invoke_with_response_stream::InvokeWithResponseStream::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::invoke_with_response_stream::InvokeWithResponseStream::orchestrate(&runtime_plugins, input).await?;
-91
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.event_stream.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-93
+    }
-94
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::invoke_with_response_stream::InvokeWithResponseStreamOutput,
         crate::operation::invoke_with_response_stream::InvokeWithResponseStreamError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-104
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-108
+    }
-109
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-113
+    }
     /// <p>The name or ARN of the Lambda function.</p>
     /// <p class="title"><b>Name formats</b></p>
     /// <ul>
     /// <li>
     /// <p><b>Function name</b> – <code>my-function</code>.</p></li>
     /// <li>
     /// <p><b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p></li>
     /// <li>
     /// <p><b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p></li>

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/select_object_content/builders.rs

@@ -124,124 +214,186 @@

↥ Expand context

     /// Access the SelectObjectContent as a reference.
     pub fn as_input(&self) -> &crate::operation::select_object_content::builders::SelectObjectContentInputBuilder {
         &self.inner
-127
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::select_object_content::SelectObjectContentOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::select_object_content::SelectObjectContentError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::select_object_content::SelectObjectContent::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::select_object_content::SelectObjectContent::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::select_object_content::SelectObjectContent::orchestrate(&runtime_plugins, input).await?;
-155
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::select_object_content::SelectObjectContentError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.payload.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-157
+    }
-158
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::select_object_content::SelectObjectContentOutput,
         crate::operation::select_object_content::SelectObjectContentError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-168
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-172
+    }
-173
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-177
+    }
     /// <p>The S3 bucket.</p>
     pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.inner = self.inner.bucket(input.into());
         self
-182
+    }
     /// <p>The S3 bucket.</p>
     pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.inner = self.inner.set_bucket(input);
         self

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/start_call_analytics_stream_transcription/builders.rs

@@ -72,72 +168,136 @@

↥ Expand context

     ) -> &crate::operation::start_call_analytics_stream_transcription::builders::StartCallAnalyticsStreamTranscriptionInputBuilder {
         &self.inner
-74
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins =
             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscription::operation_runtime_plugins(
                 self.handle.runtime_plugins.clone(),
                 &self.handle.conf,
                 self.config_override,
             );
         let mut output =
         let output =
             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscription::orchestrate(&runtime_plugins, input)
                 .await?;
-105
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output
             .call_analytics_transcript_result_stream
             .try_recv_initial_response()
             .await
             .map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-107
+    }
-108
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionOutput,
         crate::operation::start_call_analytics_stream_transcription::StartCallAnalyticsStreamTranscriptionError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-118
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-122
+    }
-123
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-127
+    }
     /// <p>Specify the language code that represents the language spoken in your audio.</p>
     /// <p>For a list of languages supported with real-time Call Analytics, refer to the <a href="https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html">Supported languages</a> table.</p>
     pub fn language_code(mut self, input: crate::types::CallAnalyticsLanguageCode) -> Self {
         self.inner = self.inner.language_code(input);
         self
-133
+    }
     /// <p>Specify the language code that represents the language spoken in your audio.</p>
     /// <p>For a list of languages supported with real-time Call Analytics, refer to the <a href="https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html">Supported languages</a> table.</p>
     pub fn set_language_code(mut self, input: ::std::option::Option<crate::types::CallAnalyticsLanguageCode>) -> Self {

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/start_medical_scribe_stream/builders.rs

@@ -73,73 +163,135 @@

↥ Expand context

     /// Access the StartMedicalScribeStream as a reference.
     pub fn as_input(&self) -> &crate::operation::start_medical_scribe_stream::builders::StartMedicalScribeStreamInputBuilder {
         &self.inner
-76
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::start_medical_scribe_stream::StartMedicalScribeStream::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::start_medical_scribe_stream::StartMedicalScribeStream::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::start_medical_scribe_stream::StartMedicalScribeStream::orchestrate(&runtime_plugins, input).await?;
-104
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output.result_stream.try_recv_initial_response().await.map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-106
+    }
-107
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamOutput,
         crate::operation::start_medical_scribe_stream::StartMedicalScribeStreamError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-117
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-121
+    }
-122
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-126
+    }
     /// <p>Specify an identifier for your streaming session (in UUID format). If you don't include a SessionId in your request, Amazon Web Services HealthScribe generates an ID and returns it in the response.</p>
     pub fn session_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.inner = self.inner.session_id(input.into());
         self
-131
+    }
     /// <p>Specify an identifier for your streaming session (in UUID format). If you don't include a SessionId in your request, Amazon Web Services HealthScribe generates an ID and returns it in the response.</p>
     pub fn set_session_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.inner = self.inner.set_session_id(input);
         self

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/start_medical_stream_transcription/builders.rs

@@ -69,69 +164,132 @@

↥ Expand context

     /// Access the StartMedicalStreamTranscription as a reference.
     pub fn as_input(&self) -> &crate::operation::start_medical_stream_transcription::builders::StartMedicalStreamTranscriptionInputBuilder {
         &self.inner
-72
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscription::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output =
         let output =
             crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscription::orchestrate(&runtime_plugins, input).await?;
-101
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output
             .transcript_result_stream
             .try_recv_initial_response()
             .await
             .map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-103
+    }
-104
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionOutput,
         crate::operation::start_medical_stream_transcription::StartMedicalStreamTranscriptionError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-114
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-118
+    }
-119
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-123
+    }
     /// <p>Specify the language code that represents the language spoken in your audio.</p><important>
     /// <p>Amazon Transcribe Medical only supports US English (<code>en-US</code>).</p>
     /// </important>
     pub fn language_code(mut self, input: crate::types::LanguageCode) -> Self {
         self.inner = self.inner.language_code(input);
         self
-130
+    }
     /// <p>Specify the language code that represents the language spoken in your audio.</p><important>
     /// <p>Amazon Transcribe Medical only supports US English (<code>en-US</code>).</p>

tmp-codegen-diff/aws-sdk/sdk/transcribestreaming/src/operation/start_stream_transcription/builders.rs

@@ -69,69 +163,131 @@

↥ Expand context

     /// Access the StartStreamTranscription as a reference.
     pub fn as_input(&self) -> &crate::operation::start_stream_transcription::builders::StartStreamTranscriptionInputBuilder {
         &self.inner
-72
+    }
     /// Sends the request and returns the response.
     ///
     /// If an error occurs, an `SdkError` will be returned with additional details that
     /// can be matched against.
     ///
     /// By default, any retryable failures will be retried twice. Retry behavior
     /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
     /// set when configuring the client.
     pub async fn send(
         self,
     ) -> ::std::result::Result<
         crate::operation::start_stream_transcription::StartStreamTranscriptionOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_stream_transcription::StartStreamTranscriptionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,

     > {
         let input = self
             .inner
             .build()
             .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
         let runtime_plugins = crate::operation::start_stream_transcription::StartStreamTranscription::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         let mut output = crate::operation::start_stream_transcription::StartStreamTranscription::orchestrate(&runtime_plugins, input).await?;
         let output = crate::operation::start_stream_transcription::StartStreamTranscription::orchestrate(&runtime_plugins, input).await?;
-100
         // Converts any error encountered beyond this point into an `SdkError` response error
         // with an `HttpResponse`. However, since we have already exited the `orchestrate`
         // function, the original `HttpResponse` is no longer available and cannot be restored.
         // This means that header information from the original response has been lost.
         //
         // Note that the response body would have been consumed by the deserializer
         // regardless, even if the initial message was hypothetically processed during
         // the orchestrator's deserialization phase but later resulted in an error.
         fn response_error(
             err: impl ::std::convert::Into<::aws_smithy_runtime_api::box_error::BoxError>,
         ) -> ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_stream_transcription::StartStreamTranscriptionError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         > {
             ::aws_smithy_runtime_api::client::result::SdkError::response_error(
                 err,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse::new(
                     ::aws_smithy_runtime_api::http::StatusCode::try_from(200).expect("valid successful code"),
                     ::aws_smithy_types::body::SdkBody::empty(),
                 ),
--
+            )
--
+        }
--
         let message = output
             .transcript_result_stream
             .try_recv_initial_response()
             .await
             .map_err(response_error)?;
--
         match message {
             ::std::option::Option::Some(_message) => ::std::result::Result::Ok(output),
             ::std::option::Option::None => ::std::result::Result::Ok(output),
--
+        }
         ::std::result::Result::Ok(output)
-102
+    }
-103
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::start_stream_transcription::StartStreamTranscriptionOutput,
         crate::operation::start_stream_transcription::StartStreamTranscriptionError,
         Self,
     > {

↧ Expand context

         crate::client::customize::CustomizableOperation::new(self)
-113
+    }
     pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         self.set_config_override(::std::option::Option::Some(config_override.into()));
         self
-117
+    }
-118
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-122
+    }
     /// <p>Specify the language code that represents the language spoken in your audio.</p>
     /// <p>If you're unsure of the language spoken in your audio, consider using <code>IdentifyLanguage</code> to enable automatic language identification.</p>
     /// <p>For a list of languages supported with Amazon Transcribe streaming, refer to the <a href="https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html">Supported languages</a> table.</p>
     pub fn language_code(mut self, input: crate::types::LanguageCode) -> Self {
         self.inner = self.inner.language_code(input);
         self
-129
+    }
     /// <p>Specify the language code that represents the language spoken in your audio.</p>
     /// <p>If you're unsure of the language spoken in your audio, consider using <code>IdentifyLanguage</code> to enable automatic language identification.</p>

Pages: 1