AWS SDK

rev. 5673a7a38b4a4a6973351c005d572863803729fe (ignoring whitespace)

Files changed:

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

@@ -0,1 +0,215 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub use crate::operation::list_async_invokes::_list_async_invokes_output::ListAsyncInvokesOutputBuilder;
-+
 pub use crate::operation::list_async_invokes::_list_async_invokes_input::ListAsyncInvokesInputBuilder;
-+
 impl crate::operation::list_async_invokes::builders::ListAsyncInvokesInputBuilder {
     /// Sends a request with this input using the given client.
     pub async fn send_with(
         self,
         client: &crate::Client,
     ) -> ::std::result::Result<
         crate::operation::list_async_invokes::ListAsyncInvokesOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_async_invokes::ListAsyncInvokesError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let mut fluent_builder = client.list_async_invokes();
         fluent_builder.inner = self;
         fluent_builder.send().await
-+
+    }
-+
+}
 /// Fluent builder constructing a request to `ListAsyncInvokes`.
 ///
 /// <p>Lists asynchronous invocations.</p>
 #[derive(::std::clone::Clone, ::std::fmt::Debug)]
 pub struct ListAsyncInvokesFluentBuilder {
     handle: ::std::sync::Arc<crate::client::Handle>,
     inner: crate::operation::list_async_invokes::builders::ListAsyncInvokesInputBuilder,
     config_override: ::std::option::Option<crate::config::Builder>,
-+
+}
 impl
     crate::client::customize::internal::CustomizableSend<
         crate::operation::list_async_invokes::ListAsyncInvokesOutput,
         crate::operation::list_async_invokes::ListAsyncInvokesError,
     > for ListAsyncInvokesFluentBuilder
-+
+{
     fn send(
         self,
         config_override: crate::config::Builder,
     ) -> crate::client::customize::internal::BoxFuture<
         crate::client::customize::internal::SendResult<
             crate::operation::list_async_invokes::ListAsyncInvokesOutput,
             crate::operation::list_async_invokes::ListAsyncInvokesError,
         >,
     > {
         ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
-+
+    }
-+
+}
 impl ListAsyncInvokesFluentBuilder {
     /// Creates a new `ListAsyncInvokesFluentBuilder`.
     pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
         Self {
             handle,
             inner: ::std::default::Default::default(),
             config_override: ::std::option::Option::None,
-+
+        }
-+
+    }
     /// Access the ListAsyncInvokes as a reference.
     pub fn as_input(&self) -> &crate::operation::list_async_invokes::builders::ListAsyncInvokesInputBuilder {
         &self.inner
-+
+    }
     /// 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::list_async_invokes::ListAsyncInvokesOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::list_async_invokes::ListAsyncInvokesError,
             ::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::list_async_invokes::ListAsyncInvokes::operation_runtime_plugins(
             self.handle.runtime_plugins.clone(),
             &self.handle.conf,
             self.config_override,
         );
         crate::operation::list_async_invokes::ListAsyncInvokes::orchestrate(&runtime_plugins, input).await
-+
+    }
-+
     /// Consumes this builder, creating a customizable operation that can be modified before being sent.
     pub fn customize(
         self,
     ) -> crate::client::customize::CustomizableOperation<
         crate::operation::list_async_invokes::ListAsyncInvokesOutput,
         crate::operation::list_async_invokes::ListAsyncInvokesError,
         Self,
     > {
         crate::client::customize::CustomizableOperation::new(self)
-+
+    }
     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
-+
+    }
-+
     pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         self.config_override = config_override;
         self
-+
+    }
     /// Create a paginator for this request
     ///
     /// Paginators are used by calling [`send().await`](crate::operation::list_async_invokes::paginator::ListAsyncInvokesPaginator::send) which returns a [`PaginationStream`](aws_smithy_async::future::pagination_stream::PaginationStream).
     pub fn into_paginator(self) -> crate::operation::list_async_invokes::paginator::ListAsyncInvokesPaginator {
         crate::operation::list_async_invokes::paginator::ListAsyncInvokesPaginator::new(self.handle, self.inner)
-+
+    }
     /// <p>Include invocations submitted after this time.</p>
     pub fn submit_time_after(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.inner = self.inner.submit_time_after(input);
         self
-+
+    }
     /// <p>Include invocations submitted after this time.</p>
     pub fn set_submit_time_after(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.inner = self.inner.set_submit_time_after(input);
         self
-+
+    }
     /// <p>Include invocations submitted after this time.</p>
     pub fn get_submit_time_after(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         self.inner.get_submit_time_after()
-+
+    }
     /// <p>Include invocations submitted before this time.</p>
     pub fn submit_time_before(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         self.inner = self.inner.submit_time_before(input);
         self
-+
+    }
     /// <p>Include invocations submitted before this time.</p>
     pub fn set_submit_time_before(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         self.inner = self.inner.set_submit_time_before(input);
         self
-+
+    }
     /// <p>Include invocations submitted before this time.</p>
     pub fn get_submit_time_before(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         self.inner.get_submit_time_before()
-+
+    }
     /// <p>Filter invocations by status.</p>
     pub fn status_equals(mut self, input: crate::types::AsyncInvokeStatus) -> Self {
         self.inner = self.inner.status_equals(input);
         self
-+
+    }
     /// <p>Filter invocations by status.</p>
     pub fn set_status_equals(mut self, input: ::std::option::Option<crate::types::AsyncInvokeStatus>) -> Self {
         self.inner = self.inner.set_status_equals(input);
         self
-+
+    }
     /// <p>Filter invocations by status.</p>
     pub fn get_status_equals(&self) -> &::std::option::Option<crate::types::AsyncInvokeStatus> {
         self.inner.get_status_equals()
-+
+    }
     /// <p>The maximum number of invocations to return in one page of results.</p>
     pub fn max_results(mut self, input: i32) -> Self {
         self.inner = self.inner.max_results(input);
         self
-+
+    }
     /// <p>The maximum number of invocations to return in one page of results.</p>
     pub fn set_max_results(mut self, input: ::std::option::Option<i32>) -> Self {
         self.inner = self.inner.set_max_results(input);
         self
-+
+    }
     /// <p>The maximum number of invocations to return in one page of results.</p>
     pub fn get_max_results(&self) -> &::std::option::Option<i32> {
         self.inner.get_max_results()
-+
+    }
     /// <p>Specify the pagination token from a previous request to retrieve the next page of results.</p>
     pub fn next_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.inner = self.inner.next_token(input.into());
         self
-+
+    }
     /// <p>Specify the pagination token from a previous request to retrieve the next page of results.</p>
     pub fn set_next_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.inner = self.inner.set_next_token(input);
         self
-+
+    }
     /// <p>Specify the pagination token from a previous request to retrieve the next page of results.</p>
     pub fn get_next_token(&self) -> &::std::option::Option<::std::string::String> {
         self.inner.get_next_token()
-+
+    }
     /// <p>How to sort the response.</p>
     pub fn sort_by(mut self, input: crate::types::SortAsyncInvocationBy) -> Self {
         self.inner = self.inner.sort_by(input);
         self
-+
+    }
     /// <p>How to sort the response.</p>
     pub fn set_sort_by(mut self, input: ::std::option::Option<crate::types::SortAsyncInvocationBy>) -> Self {
         self.inner = self.inner.set_sort_by(input);
         self
-+
+    }
     /// <p>How to sort the response.</p>
     pub fn get_sort_by(&self) -> &::std::option::Option<crate::types::SortAsyncInvocationBy> {
         self.inner.get_sort_by()
-+
+    }
     /// <p>The sorting order for the response.</p>
     pub fn sort_order(mut self, input: crate::types::SortOrder) -> Self {
         self.inner = self.inner.sort_order(input);
         self
-+
+    }
     /// <p>The sorting order for the response.</p>
     pub fn set_sort_order(mut self, input: ::std::option::Option<crate::types::SortOrder>) -> Self {
         self.inner = self.inner.set_sort_order(input);
         self
-+
+    }
     /// <p>The sorting order for the response.</p>
     pub fn get_sort_order(&self) -> &::std::option::Option<crate::types::SortOrder> {
         self.inner.get_sort_order()
-+
+    }
-+
+}

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

@@ -0,1 +0,148 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Paginator for [`ListAsyncInvokes`](crate::operation::list_async_invokes::ListAsyncInvokes)
 pub struct ListAsyncInvokesPaginator {
     handle: std::sync::Arc<crate::client::Handle>,
     builder: crate::operation::list_async_invokes::builders::ListAsyncInvokesInputBuilder,
     stop_on_duplicate_token: bool,
-+
+}
-+
 impl ListAsyncInvokesPaginator {
     /// Create a new paginator-wrapper
     pub(crate) fn new(
         handle: std::sync::Arc<crate::client::Handle>,
         builder: crate::operation::list_async_invokes::builders::ListAsyncInvokesInputBuilder,
     ) -> Self {
         Self {
             handle,
             builder,
             stop_on_duplicate_token: true,
-+
+        }
-+
+    }
-+
     /// Set the page size
     ///
     /// _Note: this method will override any previously set value for `max_results`_
     pub fn page_size(mut self, limit: i32) -> Self {
         self.builder.max_results = ::std::option::Option::Some(limit);
         self
-+
+    }
-+
     /// Create a flattened paginator
     ///
     /// This paginator automatically flattens results using `async_invoke_summaries`. Queries to the underlying service
     /// are dispatched lazily.
     pub fn items(self) -> crate::operation::list_async_invokes::paginator::ListAsyncInvokesPaginatorItems {
         crate::operation::list_async_invokes::paginator::ListAsyncInvokesPaginatorItems(self)
-+
+    }
-+
     /// Stop paginating when the service returns the same pagination token twice in a row.
     ///
     /// Defaults to true.
     ///
     /// For certain operations, it may be useful to continue on duplicate token. For example,
     /// if an operation is for tailing a log file in real-time, then continuing may be desired.
     /// This option can be set to `false` to accommodate these use cases.
     pub fn stop_on_duplicate_token(mut self, stop_on_duplicate_token: bool) -> Self {
         self.stop_on_duplicate_token = stop_on_duplicate_token;
         self
-+
+    }
-+
     /// Create the pagination stream
     ///
     /// _Note:_ No requests will be dispatched until the stream is used
     /// (e.g. with the [`.next().await`](aws_smithy_async::future::pagination_stream::PaginationStream::next) method).
     pub fn send(
         self,
     ) -> ::aws_smithy_async::future::pagination_stream::PaginationStream<
         ::std::result::Result<
             crate::operation::list_async_invokes::ListAsyncInvokesOutput,
             ::aws_smithy_runtime_api::client::result::SdkError<
                 crate::operation::list_async_invokes::ListAsyncInvokesError,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
             >,
         >,
     > {
         // Move individual fields out of self for the borrow checker
         let builder = self.builder;
         let handle = self.handle;
         let runtime_plugins = crate::operation::list_async_invokes::ListAsyncInvokes::operation_runtime_plugins(
             handle.runtime_plugins.clone(),
             &handle.conf,
             ::std::option::Option::None,
-+
+        )
         .with_operation_plugin(crate::sdk_feature_tracker::paginator::PaginatorFeatureTrackerRuntimePlugin::new());
         ::aws_smithy_async::future::pagination_stream::PaginationStream::new(::aws_smithy_async::future::pagination_stream::fn_stream::FnStream::new(
             move |tx| {
                 ::std::boxed::Box::pin(async move {
                     // Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
                     let mut input = match builder
                         .build()
                         .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)
-+
+                    {
                         ::std::result::Result::Ok(input) => input,
                         ::std::result::Result::Err(e) => {
                             let _ = tx.send(::std::result::Result::Err(e)).await;
                             return;
-+
+                        }
                     };
                     loop {
                         let resp = crate::operation::list_async_invokes::ListAsyncInvokes::orchestrate(&runtime_plugins, input.clone()).await;
                         // If the input member is None or it was an error
                         let done = match resp {
                             ::std::result::Result::Ok(ref resp) => {
                                 let new_token = crate::lens::reflens_list_async_invokes_output_output_next_token(resp);
                                 // Pagination is exhausted when the next token is an empty string
                                 let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
                                 if !is_empty && new_token == input.next_token.as_ref() && self.stop_on_duplicate_token {
                                     true
                                 } else {
                                     input.next_token = new_token.cloned();
                                     is_empty
-+
+                                }
-+
+                            }
                             ::std::result::Result::Err(_) => true,
                         };
                         if tx.send(resp).await.is_err() {
                             // receiving end was dropped
                             return;
-+
+                        }
                         if done {
                             return;
-+
+                        }
-+
+                    }
                 })
             },
         ))
-+
+    }
-+
+}
-+
 /// Flattened paginator for `ListAsyncInvokesPaginator`
 ///
 /// This is created with [`.items()`](ListAsyncInvokesPaginator::items)
 pub struct ListAsyncInvokesPaginatorItems(ListAsyncInvokesPaginator);
-+
 impl ListAsyncInvokesPaginatorItems {
     /// Create the pagination stream
     ///
     /// _Note_: No requests will be dispatched until the stream is used
     /// (e.g. with the [`.next().await`](aws_smithy_async::future::pagination_stream::PaginationStream::next) method).
     ///
     /// To read the entirety of the paginator, use [`.collect::<Result<Vec<_>, _>()`](aws_smithy_async::future::pagination_stream::PaginationStream::collect).
     pub fn send(
         self,
     ) -> ::aws_smithy_async::future::pagination_stream::PaginationStream<
         ::std::result::Result<
             crate::types::AsyncInvokeSummary,
             ::aws_smithy_runtime_api::client::result::SdkError<
                 crate::operation::list_async_invokes::ListAsyncInvokesError,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
             >,
         >,
     > {
         ::aws_smithy_async::future::pagination_stream::TryFlatMap::new(self.0.send()).flat_map(|page| {
             crate::lens::lens_list_async_invokes_output_output_async_invoke_summaries(page)
                 .unwrap_or_default()
                 .into_iter()
         })
-+
+    }
-+
+}

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

@@ -0,1 +0,442 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `StartAsyncInvoke`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartAsyncInvoke;
 impl StartAsyncInvoke {
     /// Creates a new `StartAsyncInvoke`
     pub fn new() -> Self {
         Self
-+
+    }
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_async_invoke::StartAsyncInvokeInput,
     ) -> ::std::result::Result<
         crate::operation::start_async_invoke::StartAsyncInvokeOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::start_async_invoke::StartAsyncInvokeError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::start_async_invoke::StartAsyncInvokeError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::start_async_invoke::StartAsyncInvokeOutput>()
                 .expect("correct output type"),
-+
+        )
-+
+    }
-+
     pub(crate) async fn orchestrate_with_stop_point(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::start_async_invoke::StartAsyncInvokeInput,
         stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
     ) -> ::std::result::Result<
         ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
         ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {
         let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
         use ::tracing::Instrument;
         ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point("Bedrock Runtime", "StartAsyncInvoke", input, runtime_plugins, stop_point)
             // Create a parent span for the entire operation. Includes a random, internal-only,
             // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
             .instrument(::tracing::debug_span!(
                 "Bedrock Runtime.StartAsyncInvoke",
                 "rpc.service" = "Bedrock Runtime",
                 "rpc.method" = "StartAsyncInvoke",
                 "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
                 "rpc.system" = "aws-api",
             ))
             .await
-+
+    }
-+
     pub(crate) fn operation_runtime_plugins(
         client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         client_config: &crate::config::Config,
         config_override: ::std::option::Option<crate::config::Builder>,
     ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
         let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
         runtime_plugins = runtime_plugins.with_operation_plugin(crate::client_idempotency_token::IdempotencyTokenRuntimePlugin::new(
             |token_provider, input| {
                 let input: &mut crate::operation::start_async_invoke::StartAsyncInvokeInput = input.downcast_mut().expect("correct type");
                 if input.client_request_token.is_none() {
                     input.client_request_token = ::std::option::Option::Some(token_provider.make_idempotency_token());
-+
+                }
             },
         ));
         if let ::std::option::Option::Some(config_override) = config_override {
             for plugin in config_override.runtime_plugins.iter().cloned() {
                 runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
-+
+            }
             runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
                 config_override,
                 client_config.config.clone(),
                 &client_config.runtime_components,
             ));
-+
+        }
         runtime_plugins
-+
+    }
-+
+}
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for StartAsyncInvoke {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         let mut cfg = ::aws_smithy_types::config_bag::Layer::new("StartAsyncInvoke");
-+
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
             StartAsyncInvokeRequestSerializer,
         ));
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             StartAsyncInvokeResponseDeserializer,
         ));
-+
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             crate::config::auth::Params::builder()
                 .operation_name("StartAsyncInvoke")
                 .build()
                 .expect("required fields set"),
         ));
-+
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "StartAsyncInvoke",
             "Bedrock Runtime",
         ));
         let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         signing_options.double_uri_encode = true;
         signing_options.content_sha256_header = false;
         signing_options.normalize_uri_path = true;
         signing_options.payload_override = None;
-+
         cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
             signing_options,
             ..::std::default::Default::default()
         });
-+
         ::std::option::Option::Some(cfg.freeze())
-+
+    }
-+
     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("StartAsyncInvoke")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(StartAsyncInvokeEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::start_async_invoke::StartAsyncInvokeError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::start_async_invoke::StartAsyncInvokeError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                 crate::operation::start_async_invoke::StartAsyncInvokeError,
             >::new());
-+
         ::std::borrow::Cow::Owned(rcb)
-+
+    }
-+
+}
-+
 #[derive(Debug)]
 struct StartAsyncInvokeResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartAsyncInvokeResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_start_async_invoke::de_start_async_invoke_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_start_async_invoke::de_start_async_invoke_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-+
+    }
-+
+}
 #[derive(Debug)]
 struct StartAsyncInvokeRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartAsyncInvokeRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::start_async_invoke::StartAsyncInvokeInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::start_async_invoke::StartAsyncInvokeInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/async-invoke").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-+
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_async_invoke::StartAsyncInvokeInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::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::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_start_async_invoke::ser_start_async_invoke_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::header::CONTENT_LENGTH, &content_length);
-+
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
+    }
-+
+}
 #[derive(Debug)]
 struct StartAsyncInvokeEndpointParamsInterceptor;
-+
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartAsyncInvokeEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartAsyncInvokeEndpointParamsInterceptor"
-+
+    }
-+
     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::<StartAsyncInvokeInput>()
             .ok_or("failed to downcast to StartAsyncInvokeInput")?;
-+
         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()))
             .build()
             .map_err(|err| {
                 ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
             })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-+
+    }
-+
+}
-+
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-+
 /// Error type for the `StartAsyncInvokeError` operation.
 #[non_exhaustive]
 #[derive(::std::fmt::Debug)]
 pub enum StartAsyncInvokeError {
     /// <p>The request is denied because you do not have sufficient permissions to perform the requested action. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-access-denied">AccessDeniedException</a> in the Amazon Bedrock User Guide</p>
     AccessDeniedException(crate::types::error::AccessDeniedException),
     /// <p>Error occurred because of a conflict while performing an operation.</p>
     ConflictException(crate::types::error::ConflictException),
     /// <p>An internal server error occurred. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-internal-failure">InternalFailure</a> in the Amazon Bedrock User Guide</p>
     InternalServerException(crate::types::error::InternalServerException),
     /// <p>The specified resource ARN was not found. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-resource-not-found">ResourceNotFound</a> in the Amazon Bedrock User Guide</p>
     ResourceNotFoundException(crate::types::error::ResourceNotFoundException),
     /// <p>Your request exceeds the service quota for your account. You can view your quotas at <a href="https://docs.aws.amazon.com/servicequotas/latest/userguide/gs-request-quota.html">Viewing service quotas</a>. You can resubmit your request later.</p>
     ServiceQuotaExceededException(crate::types::error::ServiceQuotaExceededException),
     /// <p>The service isn't currently available. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-service-unavailable">ServiceUnavailable</a> in the Amazon Bedrock User Guide</p>
     ServiceUnavailableException(crate::types::error::ServiceUnavailableException),
     /// <p>Your request was denied due to exceeding the account quotas for <i>Amazon Bedrock</i>. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-throttling-exception">ThrottlingException</a> in the Amazon Bedrock User Guide</p>
     ThrottlingException(crate::types::error::ThrottlingException),
     /// <p>The input fails to satisfy the constraints specified by <i>Amazon Bedrock</i>. For troubleshooting this error, see <a href="https://docs.aws.amazon.com/bedrock/latest/userguide/troubleshooting-api-error-codes.html#ts-validation-error">ValidationError</a> in the Amazon Bedrock User Guide</p>
     ValidationException(crate::types::error::ValidationException),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-+
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-+
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-StartAsyncInvokeError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
-+
+}
 impl StartAsyncInvokeError {
     /// Creates the `StartAsyncInvokeError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-+
+    }
-+
     /// Creates the `StartAsyncInvokeError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
     pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.clone().into(),
             meta: err,
         })
-+
+    }
     ///
     /// Returns error metadata, which includes the error code, message,
     /// request ID, and potentially additional information.
     ///
     pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         match self {
             Self::AccessDeniedException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::ConflictException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::InternalServerException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::ResourceNotFoundException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::ServiceQuotaExceededException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::ServiceUnavailableException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::ThrottlingException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::ValidationException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::Unhandled(e) => &e.meta,
-+
+        }
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::AccessDeniedException`.
     pub fn is_access_denied_exception(&self) -> bool {
         matches!(self, Self::AccessDeniedException(_))
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::ConflictException`.
     pub fn is_conflict_exception(&self) -> bool {
         matches!(self, Self::ConflictException(_))
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::InternalServerException`.
     pub fn is_internal_server_exception(&self) -> bool {
         matches!(self, Self::InternalServerException(_))
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::ResourceNotFoundException`.
     pub fn is_resource_not_found_exception(&self) -> bool {
         matches!(self, Self::ResourceNotFoundException(_))
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::ServiceQuotaExceededException`.
     pub fn is_service_quota_exceeded_exception(&self) -> bool {
         matches!(self, Self::ServiceQuotaExceededException(_))
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::ServiceUnavailableException`.
     pub fn is_service_unavailable_exception(&self) -> bool {
         matches!(self, Self::ServiceUnavailableException(_))
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::ThrottlingException`.
     pub fn is_throttling_exception(&self) -> bool {
         matches!(self, Self::ThrottlingException(_))
-+
+    }
     /// Returns `true` if the error kind is `StartAsyncInvokeError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(self, Self::ValidationException(_))
-+
+    }
-+
+}
 impl ::std::error::Error for StartAsyncInvokeError {
     fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match self {
             Self::AccessDeniedException(_inner) => ::std::option::Option::Some(_inner),
             Self::ConflictException(_inner) => ::std::option::Option::Some(_inner),
             Self::InternalServerException(_inner) => ::std::option::Option::Some(_inner),
             Self::ResourceNotFoundException(_inner) => ::std::option::Option::Some(_inner),
             Self::ServiceQuotaExceededException(_inner) => ::std::option::Option::Some(_inner),
             Self::ServiceUnavailableException(_inner) => ::std::option::Option::Some(_inner),
             Self::ThrottlingException(_inner) => ::std::option::Option::Some(_inner),
             Self::ValidationException(_inner) => ::std::option::Option::Some(_inner),
             Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
-+
+        }
-+
+    }
-+
+}
 impl ::std::fmt::Display for StartAsyncInvokeError {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match self {
             Self::AccessDeniedException(_inner) => _inner.fmt(f),
             Self::ConflictException(_inner) => _inner.fmt(f),
             Self::InternalServerException(_inner) => _inner.fmt(f),
             Self::ResourceNotFoundException(_inner) => _inner.fmt(f),
             Self::ServiceQuotaExceededException(_inner) => _inner.fmt(f),
             Self::ServiceUnavailableException(_inner) => _inner.fmt(f),
             Self::ThrottlingException(_inner) => _inner.fmt(f),
             Self::ValidationException(_inner) => _inner.fmt(f),
             Self::Unhandled(_inner) => {
                 if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
                     write!(f, "unhandled error ({code})")
                 } else {
                     f.write_str("unhandled error")
-+
+                }
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl ::aws_smithy_types::retry::ProvideErrorKind for StartAsyncInvokeError {
     fn code(&self) -> ::std::option::Option<&str> {
         ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
-+
+    }
     fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
         ::std::option::Option::None
-+
+    }
-+
+}
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for StartAsyncInvokeError {
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         match self {
             Self::AccessDeniedException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::ConflictException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::InternalServerException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::ResourceNotFoundException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::ServiceQuotaExceededException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::ServiceUnavailableException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::ThrottlingException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::ValidationException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::Unhandled(_inner) => &_inner.meta,
-+
+        }
-+
+    }
-+
+}
 impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for StartAsyncInvokeError {
     fn create_unhandled_error(
         source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
         meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source,
             meta: meta.unwrap_or_default(),
         })
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for crate::operation::start_async_invoke::StartAsyncInvokeError {
     fn request_id(&self) -> Option<&str> {
         self.meta().request_id()
-+
+    }
-+
+}
-+
 pub use crate::operation::start_async_invoke::_start_async_invoke_output::StartAsyncInvokeOutput;
-+
 pub use crate::operation::start_async_invoke::_start_async_invoke_input::StartAsyncInvokeInput;
-+
 mod _start_async_invoke_input;
-+
 mod _start_async_invoke_output;
-+
 /// Builders
 pub mod builders;

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

@@ -0,1 +0,172 @@

 // 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)]
 pub struct StartAsyncInvokeInput {
     /// <p>Specify idempotency token to ensure that requests are not duplicated.</p>
     pub client_request_token: ::std::option::Option<::std::string::String>,
     /// <p>The model to invoke.</p>
     pub model_id: ::std::option::Option<::std::string::String>,
     /// <p>Input to send to the model.</p>
     pub model_input: ::std::option::Option<::aws_smithy_types::Document>,
     /// <p>Where to store the output.</p>
     pub output_data_config: ::std::option::Option<crate::types::AsyncInvokeOutputDataConfig>,
     /// <p>Tags to apply to the invocation.</p>
     pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-+
+}
 impl StartAsyncInvokeInput {
     /// <p>Specify idempotency token to ensure that requests are not duplicated.</p>
     pub fn client_request_token(&self) -> ::std::option::Option<&str> {
         self.client_request_token.as_deref()
-+
+    }
     /// <p>The model to invoke.</p>
     pub fn model_id(&self) -> ::std::option::Option<&str> {
         self.model_id.as_deref()
-+
+    }
     /// <p>Input to send to the model.</p>
     pub fn model_input(&self) -> ::std::option::Option<&::aws_smithy_types::Document> {
         self.model_input.as_ref()
-+
+    }
     /// <p>Where to store the output.</p>
     pub fn output_data_config(&self) -> ::std::option::Option<&crate::types::AsyncInvokeOutputDataConfig> {
         self.output_data_config.as_ref()
-+
+    }
     /// <p>Tags to apply to the invocation.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
     pub fn tags(&self) -> &[crate::types::Tag] {
         self.tags.as_deref().unwrap_or_default()
-+
+    }
-+
+}
 impl ::std::fmt::Debug for StartAsyncInvokeInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("StartAsyncInvokeInput");
         formatter.field("client_request_token", &self.client_request_token);
         formatter.field("model_id", &self.model_id);
         formatter.field("model_input", &"*** Sensitive Data Redacted ***");
         formatter.field("output_data_config", &self.output_data_config);
         formatter.field("tags", &self.tags);
         formatter.finish()
-+
+    }
-+
+}
 impl StartAsyncInvokeInput {
     /// Creates a new builder-style object to manufacture [`StartAsyncInvokeInput`](crate::operation::start_async_invoke::StartAsyncInvokeInput).
     pub fn builder() -> crate::operation::start_async_invoke::builders::StartAsyncInvokeInputBuilder {
         crate::operation::start_async_invoke::builders::StartAsyncInvokeInputBuilder::default()
-+
+    }
-+
+}
-+
 /// A builder for [`StartAsyncInvokeInput`](crate::operation::start_async_invoke::StartAsyncInvokeInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]
 pub struct StartAsyncInvokeInputBuilder {
     pub(crate) client_request_token: ::std::option::Option<::std::string::String>,
     pub(crate) model_id: ::std::option::Option<::std::string::String>,
     pub(crate) model_input: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) output_data_config: ::std::option::Option<crate::types::AsyncInvokeOutputDataConfig>,
     pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
-+
+}
 impl StartAsyncInvokeInputBuilder {
     /// <p>Specify idempotency token to ensure that requests are not duplicated.</p>
     pub fn client_request_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.client_request_token = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>Specify idempotency token to ensure that requests are not duplicated.</p>
     pub fn set_client_request_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.client_request_token = input;
         self
-+
+    }
     /// <p>Specify idempotency token to ensure that requests are not duplicated.</p>
     pub fn get_client_request_token(&self) -> &::std::option::Option<::std::string::String> {
         &self.client_request_token
-+
+    }
     /// <p>The model to invoke.</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
-+
+    }
     /// <p>The model to invoke.</p>
     pub fn set_model_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.model_id = input;
         self
-+
+    }
     /// <p>The model to invoke.</p>
     pub fn get_model_id(&self) -> &::std::option::Option<::std::string::String> {
         &self.model_id
-+
+    }
     /// <p>Input to send to the model.</p>
     /// This field is required.
     pub fn model_input(mut self, input: ::aws_smithy_types::Document) -> Self {
         self.model_input = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>Input to send to the model.</p>
     pub fn set_model_input(mut self, input: ::std::option::Option<::aws_smithy_types::Document>) -> Self {
         self.model_input = input;
         self
-+
+    }
     /// <p>Input to send to the model.</p>
     pub fn get_model_input(&self) -> &::std::option::Option<::aws_smithy_types::Document> {
         &self.model_input
-+
+    }
     /// <p>Where to store the output.</p>
     /// This field is required.
     pub fn output_data_config(mut self, input: crate::types::AsyncInvokeOutputDataConfig) -> Self {
         self.output_data_config = ::std::option::Option::Some(input);
         self
-+
+    }
     /// <p>Where to store the output.</p>
     pub fn set_output_data_config(mut self, input: ::std::option::Option<crate::types::AsyncInvokeOutputDataConfig>) -> Self {
         self.output_data_config = input;
         self
-+
+    }
     /// <p>Where to store the output.</p>
     pub fn get_output_data_config(&self) -> &::std::option::Option<crate::types::AsyncInvokeOutputDataConfig> {
         &self.output_data_config
-+
+    }
     /// Appends an item to `tags`.
     ///
     /// To override the contents of this collection use [`set_tags`](Self::set_tags).
     ///
     /// <p>Tags to apply to the invocation.</p>
     pub fn tags(mut self, input: crate::types::Tag) -> Self {
         let mut v = self.tags.unwrap_or_default();
         v.push(input);
         self.tags = ::std::option::Option::Some(v);
         self
-+
+    }
     /// <p>Tags to apply to the invocation.</p>
     pub fn set_tags(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>) -> Self {
         self.tags = input;
         self
-+
+    }
     /// <p>Tags to apply to the invocation.</p>
     pub fn get_tags(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Tag>> {
         &self.tags
-+
+    }
     /// Consumes the builder and constructs a [`StartAsyncInvokeInput`](crate::operation::start_async_invoke::StartAsyncInvokeInput).
     pub fn build(
         self,
     ) -> ::std::result::Result<crate::operation::start_async_invoke::StartAsyncInvokeInput, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::operation::start_async_invoke::StartAsyncInvokeInput {
             client_request_token: self.client_request_token,
             model_id: self.model_id,
             model_input: self.model_input,
             output_data_config: self.output_data_config,
             tags: self.tags,
         })
-+
+    }
-+
+}
 impl ::std::fmt::Debug for StartAsyncInvokeInputBuilder {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("StartAsyncInvokeInputBuilder");
         formatter.field("client_request_token", &self.client_request_token);
         formatter.field("model_id", &self.model_id);
         formatter.field("model_input", &"*** Sensitive Data Redacted ***");
         formatter.field("output_data_config", &self.output_data_config);
         formatter.field("tags", &self.tags);
         formatter.finish()
-+
+    }
-+
+}

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

@@ -0,1 +0,77 @@

 // 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 StartAsyncInvokeOutput {
     /// <p>The ARN of the invocation.</p>
     pub invocation_arn: ::std::string::String,
     _request_id: Option<String>,
-+
+}
 impl StartAsyncInvokeOutput {
     /// <p>The ARN of the invocation.</p>
     pub fn invocation_arn(&self) -> &str {
         use std::ops::Deref;
         self.invocation_arn.deref()
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for StartAsyncInvokeOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-+
+    }
-+
+}
 impl StartAsyncInvokeOutput {
     /// Creates a new builder-style object to manufacture [`StartAsyncInvokeOutput`](crate::operation::start_async_invoke::StartAsyncInvokeOutput).
     pub fn builder() -> crate::operation::start_async_invoke::builders::StartAsyncInvokeOutputBuilder {
         crate::operation::start_async_invoke::builders::StartAsyncInvokeOutputBuilder::default()
-+
+    }
-+
+}
-+
 /// A builder for [`StartAsyncInvokeOutput`](crate::operation::start_async_invoke::StartAsyncInvokeOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct StartAsyncInvokeOutputBuilder {
     pub(crate) invocation_arn: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-+
+}
 impl StartAsyncInvokeOutputBuilder {
     /// <p>The ARN of the invocation.</p>
     /// This field is required.
     pub fn invocation_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.invocation_arn = ::std::option::Option::Some(input.into());
         self
-+
+    }
     /// <p>The ARN of the invocation.</p>
     pub fn set_invocation_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.invocation_arn = input;
         self
-+
+    }
     /// <p>The ARN of the invocation.</p>
     pub fn get_invocation_arn(&self) -> &::std::option::Option<::std::string::String> {
         &self.invocation_arn
-+
+    }
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-+
+    }
-+
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-+
+    }
     /// Consumes the builder and constructs a [`StartAsyncInvokeOutput`](crate::operation::start_async_invoke::StartAsyncInvokeOutput).
     /// This method will fail if any of the following fields are not set:
     /// - [`invocation_arn`](crate::operation::start_async_invoke::builders::StartAsyncInvokeOutputBuilder::invocation_arn)
     pub fn build(
         self,
     ) -> ::std::result::Result<crate::operation::start_async_invoke::StartAsyncInvokeOutput, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::operation::start_async_invoke::StartAsyncInvokeOutput {
             invocation_arn: self.invocation_arn.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "invocation_arn",
                     "invocation_arn was not specified but it is required when building StartAsyncInvokeOutput",
-+
+                )
             })?,
             _request_id: self._request_id,
         })
-+
+    }
-+
+}

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29