AWS SDK

tmp-codegen-diff/aws-sdk/sdk/aws-types/Cargo.toml

@@ -7,7 +77,81 @@

 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/smithy-lang/smithy-rs"
 rust-version = "1.91.1"
 [package.metadata.docs.rs]
 all-features = true
 targets = ["x86_64-unknown-linux-gnu"]
 cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
 rustdoc-args = ["--cfg", "docsrs"]
-16
 [package.metadata.smithy-rs-release-tooling]
 stable = true
 [package.metadata.cargo-udeps.ignore]
 normal = ["aws-smithy-runtime", "hyper-rustls"]
 development = ["aws-smithy-runtime"]
-22
 [features]
 examples = ["dep:hyper-rustls", "aws-smithy-runtime/client", "aws-smithy-runtime/connector-hyper-0-14-x", "aws-smithy-runtime/tls-rustls"]
-25
 [dependencies]

 tracing = "0.1.44"
-28
 [dependencies.aws-credential-types]
 path = "../aws-credential-types"
 version = "1.2.14"
-32
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.14"
-36
 [dependencies.aws-smithy-schema]
 path = "../aws-smithy-schema"
 version = "1.0.0"
-+
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 version = "1.4.7"
-44
 [dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 optional = true
 version = "1.10.3"
 version = "1.10.4"
-49
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client"]
 version = "1.11.6"
 version = "1.11.7"
-54
 [dependencies.hyper-rustls]
 version = "0.24.2"
 optional = true
 default-features = false
 features = ["http2", "webpki-roots"]
-60
 [dev-dependencies]
 http = "0.2.4"
 tempfile = "3.16.0"
 tracing-test = "0.2.5"
-65
 [dev-dependencies.tokio]
 version = "1"
 features = ["rt", "macros"]
-69
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["http-02x"]
 version = "1.11.6"
 version = "1.11.7"
-74
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client"]
 version = "1.10.3"
 version = "1.10.4"
-79
 [build-dependencies]
 rustc_version = "0.4.0"

tmp-codegen-diff/aws-sdk/sdk/aws-types/src/sdk_config.rs

@@ -1,1 +59,60 @@

↥ Expand context

 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-5
 #![deny(missing_docs)]
-7
 //! AWS Shared Config
 //!
 //! This module contains a shared configuration representation that is agnostic from a specific service.
-11
 use crate::app_name::AppName;
 use crate::docs_for;
 use crate::endpoint_config::AccountIdEndpointMode;
 use crate::origin::Origin;
 use crate::region::{Region, SigningRegionSet};
 use crate::service_config::LoadServiceConfig;
 use aws_credential_types::provider::token::SharedTokenProvider;
 pub use aws_credential_types::provider::SharedCredentialsProvider;

 use aws_smithy_async::rt::sleep::AsyncSleep;
 pub use aws_smithy_async::rt::sleep::SharedAsyncSleep;
 pub use aws_smithy_async::time::{SharedTimeSource, TimeSource};
 use aws_smithy_runtime_api::client::auth::AuthSchemePreference;
 use aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
 use aws_smithy_runtime_api::client::http::HttpClient;
 pub use aws_smithy_runtime_api::client::http::SharedHttpClient;
 use aws_smithy_runtime_api::client::identity::{ResolveCachedIdentity, SharedIdentityCache};
 pub use aws_smithy_runtime_api::client::stalled_stream_protection::StalledStreamProtectionConfig;
 use aws_smithy_runtime_api::shared::IntoShared;
 use aws_smithy_schema::protocol::SharedClientProtocol;
 pub use aws_smithy_types::checksum_config::{
     RequestChecksumCalculation, ResponseChecksumValidation,
 };
 pub use aws_smithy_types::retry::RetryConfig;
 pub use aws_smithy_types::timeout::TimeoutConfig;
 use std::collections::HashMap;
 use std::sync::Arc;
-38
 /// Unified docstrings to keep crates in sync. Not intended for public use
 pub mod unified_docs {

↧ Expand context

     /// A macro that generates docs for selected fields of `SdkConfig`.
     #[macro_export]
     macro_rules! docs_for {
         (use_fips) => {
 "When true, send this request to the FIPS-compliant regional endpoint.
-46
 If no FIPS-compliant endpoint can be determined, dispatching the request will return an error."
         };
         (use_dual_stack) => {
 "When true, send this request to the dual-stack endpoint.
-51
 If no dual-stack endpoint is available the request MAY return an error.
-53
 **Note**: Some services do not offer dual-stack as a configurable parameter (e.g. Code Catalyst). For
 these services, this setting has no effect"
         };
         (time_source) => {
 "The time source use to use for this client.
-59
 This only needs to be required for creating deterministic tests or platforms where `SystemTime::now()` is not supported."};

@@ -103,104 +195,198 @@

↥ Expand context

-104
+    }
-105
+}
-106
 /// AWS Shared Configuration
 #[derive(Debug, Clone)]
 pub struct SdkConfig {
     app_name: Option<AppName>,
     auth_scheme_preference: Option<AuthSchemePreference>,
     sigv4a_signing_region_set: Option<SigningRegionSet>,
     identity_cache: Option<SharedIdentityCache>,
     credentials_provider: Option<SharedCredentialsProvider>,
     token_provider: Option<SharedTokenProvider>,
     region: Option<Region>,
     account_id_endpoint_mode: Option<AccountIdEndpointMode>,
     endpoint_url: Option<String>,
     retry_config: Option<RetryConfig>,
     sleep_impl: Option<SharedAsyncSleep>,
     time_source: Option<SharedTimeSource>,
     timeout_config: Option<TimeoutConfig>,
     stalled_stream_protection_config: Option<StalledStreamProtectionConfig>,

     http_client: Option<SharedHttpClient>,
     use_fips: Option<bool>,
     use_dual_stack: Option<bool>,
     behavior_version: Option<BehaviorVersion>,
     service_config: Option<Arc<dyn LoadServiceConfig>>,
     config_origins: HashMap<&'static str, Origin>,
     disable_request_compression: Option<bool>,
     request_min_compression_size_bytes: Option<u32>,
     request_checksum_calculation: Option<RequestChecksumCalculation>,
     response_checksum_validation: Option<ResponseChecksumValidation>,
     protocol: Option<SharedClientProtocol>,
-135
+}
-136
 /// Builder for AWS Shared Configuration
 ///
 /// _Important:_ Using the `aws-config` crate to configure the SDK is preferred to invoking this
 /// builder directly. Using this builder directly won't pull in any AWS recommended default
 /// configuration values.
 #[derive(Debug, Default)]
 pub struct Builder {
     app_name: Option<AppName>,
     auth_scheme_preference: Option<AuthSchemePreference>,
     sigv4a_signing_region_set: Option<SigningRegionSet>,
     identity_cache: Option<SharedIdentityCache>,
     credentials_provider: Option<SharedCredentialsProvider>,
     token_provider: Option<SharedTokenProvider>,
     region: Option<Region>,
     account_id_endpoint_mode: Option<AccountIdEndpointMode>,
     endpoint_url: Option<String>,
     retry_config: Option<RetryConfig>,
     sleep_impl: Option<SharedAsyncSleep>,
     time_source: Option<SharedTimeSource>,
     timeout_config: Option<TimeoutConfig>,
     stalled_stream_protection_config: Option<StalledStreamProtectionConfig>,
     http_client: Option<SharedHttpClient>,
     use_fips: Option<bool>,
     use_dual_stack: Option<bool>,
     behavior_version: Option<BehaviorVersion>,
     service_config: Option<Arc<dyn LoadServiceConfig>>,
     config_origins: HashMap<&'static str, Origin>,
     disable_request_compression: Option<bool>,
     request_min_compression_size_bytes: Option<u32>,
     request_checksum_calculation: Option<RequestChecksumCalculation>,
     response_checksum_validation: Option<ResponseChecksumValidation>,
     protocol: Option<SharedClientProtocol>,
-169
+}
-170
 impl Builder {
     /// Set the region for the builder
     ///
     /// # Examples
     /// ```rust
     /// use aws_types::SdkConfig;
     /// use aws_types::region::Region;
     /// let config = SdkConfig::builder().region(Region::new("us-east-1")).build();

↧ Expand context

     /// ```
     pub fn region(mut self, region: impl Into<Option<Region>>) -> Self {
         self.set_region(region);
         self
-183
+    }
-184
     /// Set the region for the builder
     ///
     /// # Examples
     /// ```rust
     /// fn region_override() -> Option<Region> {
     ///     // ...
     ///     # None
     /// }
     /// use aws_types::SdkConfig;
     /// use aws_types::region::Region;
     /// let mut builder = SdkConfig::builder();
     /// if let Some(region) = region_override() {
     ///     builder.set_region(region);
     /// }

@@ -668,671 +727,748 @@

↥ Expand context

     /// use aws_types::sdk_config::{Builder, SdkConfig, TimeoutConfig};
     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     /// use std::time::Duration;
     ///
     /// fn override_http_client(builder: &mut Builder) {
     ///     // Create a connector that will be used to establish TLS connections
     ///     let tls_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///         .with_webpki_roots()
     ///         .https_only()
     ///         .enable_http1()
     ///         .enable_http2()
     ///         .build();
     ///     // Create a HTTP client that uses the TLS connector. This client is
     ///     // responsible for creating and caching a HttpConnector when given HttpConnectorSettings.
     ///     // This hyper client will create HttpConnectors backed by hyper and the tls_connector.
     ///     let http_client = HyperClientBuilder::new().build(tls_connector);
     ///
     ///     builder.set_http_client(Some(http_client));
     /// }
     ///

     /// let mut builder = SdkConfig::builder();
     /// override_http_client(&mut builder);
     /// let config = builder.build();
     /// # }
     /// ```
     pub fn set_http_client(&mut self, http_client: Option<SharedHttpClient>) -> &mut Self {
         self.http_client = http_client;
         self
-699
+    }
-700
     /// Sets the client protocol to use for serialization and deserialization.
     ///
     /// This overrides the default protocol determined by the service model,
     /// enabling runtime protocol selection.
     pub fn protocol(
         mut self,
         protocol: impl aws_smithy_schema::protocol::ClientProtocol + 'static,
     ) -> Self {
         self.set_protocol(Some(SharedClientProtocol::new(protocol)));
         self
-+
+    }
-+
     /// Sets the client protocol to use for serialization and deserialization.
     pub fn set_protocol(&mut self, protocol: Option<SharedClientProtocol>) -> &mut Self {
         self.protocol = protocol;
         self
-+
+    }
-+
     #[doc = docs_for!(use_fips)]
     pub fn use_fips(mut self, use_fips: bool) -> Self {
         self.set_use_fips(Some(use_fips));
         self
-723
+    }
-724
     #[doc = docs_for!(use_fips)]
     pub fn set_use_fips(&mut self, use_fips: Option<bool>) -> &mut Self {
         self.use_fips = use_fips;
         self

↧ Expand context

-729
+    }
-730
     #[doc = docs_for!(use_dual_stack)]
     pub fn use_dual_stack(mut self, use_dual_stack: bool) -> Self {
         self.set_use_dual_stack(Some(use_dual_stack));
         self
-735
+    }
-736
     #[doc = docs_for!(use_dual_stack)]
     pub fn set_use_dual_stack(&mut self, use_dual_stack: Option<bool>) -> &mut Self {
         self.use_dual_stack = use_dual_stack;
         self
-741
+    }
-742
     #[doc = docs_for!(time_source)]
     pub fn time_source(mut self, time_source: impl TimeSource + 'static) -> Self {
         self.set_time_source(Some(SharedTimeSource::new(time_source)));
         self
-747
+    }
-748

@@ -843,864 +902,924 @@

↥ Expand context

         self.config_origins.insert(setting, origin);
-865
+    }
-866
     /// Build a [`SdkConfig`] from this builder.
     pub fn build(self) -> SdkConfig {
         SdkConfig {
             app_name: self.app_name,
             auth_scheme_preference: self.auth_scheme_preference,
             sigv4a_signing_region_set: self.sigv4a_signing_region_set,
             identity_cache: self.identity_cache,
             credentials_provider: self.credentials_provider,
             token_provider: self.token_provider,
             region: self.region,
             account_id_endpoint_mode: self.account_id_endpoint_mode,
             endpoint_url: self.endpoint_url,
             retry_config: self.retry_config,
             sleep_impl: self.sleep_impl,
             timeout_config: self.timeout_config,
             http_client: self.http_client,
             use_fips: self.use_fips,

             use_dual_stack: self.use_dual_stack,
             time_source: self.time_source,
             behavior_version: self.behavior_version,
             stalled_stream_protection_config: self.stalled_stream_protection_config,
             service_config: self.service_config,
             config_origins: self.config_origins,
             disable_request_compression: self.disable_request_compression,
             request_min_compression_size_bytes: self.request_min_compression_size_bytes,
             request_checksum_calculation: self.request_checksum_calculation,
             response_checksum_validation: self.response_checksum_validation,
             protocol: self.protocol,
-895
+        }
-896
+    }
-897
+}
-898
 impl Builder {
     /// Set the [`StalledStreamProtectionConfig`] to configure protection for stalled streams.
     ///
     /// This configures stalled stream protection. When enabled, download streams
     /// that stall (stream no data) for longer than a configured grace period will return an error.
     ///

↧ Expand context

     /// _Note:_ Stalled stream protection requires both a sleep implementation and a time source
     /// in order to work. When enabling stalled stream protection, make sure to set
     /// - A sleep impl with [Self::sleep_impl] or [Self::set_sleep_impl].
     /// - A time source with [Self::time_source] or [Self::set_time_source].
     ///
     /// # Examples
     /// ```rust
     /// use std::time::Duration;
     /// use aws_types::SdkConfig;
     /// pub use aws_smithy_runtime_api::client::stalled_stream_protection::StalledStreamProtectionConfig;
     ///
     /// let stalled_stream_protection_config = StalledStreamProtectionConfig::enabled()
     ///     .grace_period(Duration::from_secs(1))
     ///     .build();
     /// let config = SdkConfig::builder()
     ///     .stalled_stream_protection(stalled_stream_protection_config)
     ///     .build();
     /// ```
     pub fn stalled_stream_protection(
         mut self,

@@ -989,1011 +1048,1075 @@

↥ Expand context

     /// Configured identity cache
     pub fn identity_cache(&self) -> Option<SharedIdentityCache> {
         self.identity_cache.clone()
-1014
+    }
-1015
     /// Configured credentials provider
     pub fn credentials_provider(&self) -> Option<SharedCredentialsProvider> {
         self.credentials_provider.clone()
-1019
+    }
-1020
     /// Configured bearer auth token provider
     pub fn token_provider(&self) -> Option<SharedTokenProvider> {
         self.token_provider.clone()
-1024
+    }
-1025
     /// Configured time source
     pub fn time_source(&self) -> Option<SharedTimeSource> {
         self.time_source.clone()
-1029
+    }
-1030

     /// Configured app name
     pub fn app_name(&self) -> Option<&AppName> {
         self.app_name.as_ref()
-1034
+    }
-1035
     /// Configured HTTP client
     pub fn http_client(&self) -> Option<SharedHttpClient> {
         self.http_client.clone()
-1039
+    }
-1040
     /// Configured client protocol for serialization and deserialization
     pub fn protocol(&self) -> Option<SharedClientProtocol> {
         self.protocol.clone()
-+
+    }
-+
     /// Use FIPS endpoints
     pub fn use_fips(&self) -> Option<bool> {
         self.use_fips
-1049
+    }
-1050
     /// Use dual-stack endpoint
     pub fn use_dual_stack(&self) -> Option<bool> {
         self.use_dual_stack
-1054
+    }
-1055

↧ Expand context

     /// When true, request compression is disabled.
     pub fn disable_request_compression(&self) -> Option<bool> {
         self.disable_request_compression
-1059
+    }
-1060
     /// Configured checksum request behavior.
     pub fn request_checksum_calculation(&self) -> Option<RequestChecksumCalculation> {
         self.request_checksum_calculation
-1064
+    }
-1065
     /// Configured checksum response behavior.
     pub fn response_checksum_validation(&self) -> Option<ResponseChecksumValidation> {
         self.response_checksum_validation
-1069
+    }
-1070
     /// Configured minimum request compression size.
     pub fn request_min_compression_size_bytes(&self) -> Option<u32> {
         self.request_min_compression_size_bytes
-1074
+    }
-1075

@@ -1086,1113 +1118,1146 @@

↥ Expand context

             .unwrap_or_default()
-1114
+    }
-1115
     /// Convert this [`SdkConfig`] back to a builder to enable modification
     pub fn into_builder(self) -> Builder {
         Builder {
             app_name: self.app_name,
             auth_scheme_preference: self.auth_scheme_preference,
             sigv4a_signing_region_set: self.sigv4a_signing_region_set,
             identity_cache: self.identity_cache,
             credentials_provider: self.credentials_provider,
             token_provider: self.token_provider,
             region: self.region,
             account_id_endpoint_mode: self.account_id_endpoint_mode,
             endpoint_url: self.endpoint_url,
             retry_config: self.retry_config,
             sleep_impl: self.sleep_impl,
             time_source: self.time_source,
             timeout_config: self.timeout_config,
             http_client: self.http_client,

             use_fips: self.use_fips,
             use_dual_stack: self.use_dual_stack,
             behavior_version: self.behavior_version,
             stalled_stream_protection_config: self.stalled_stream_protection_config,
             service_config: self.service_config,
             config_origins: self.config_origins,
             disable_request_compression: self.disable_request_compression,
             request_min_compression_size_bytes: self.request_min_compression_size_bytes,
             request_checksum_calculation: self.request_checksum_calculation,
             response_checksum_validation: self.response_checksum_validation,
             protocol: self.protocol,
-1144
+        }
-1145
+    }
-1146
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/Cargo.toml

@@ -25,25 +90,90 @@

↥ Expand context

 version = "1.7.3"
-26
 [dependencies.aws-sigv4]
 path = "../aws-sigv4"
 version = "1.4.2"
-30
 [dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 version = "1.2.14"
-34
 [dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 version = "0.60.20"
-38
 [dependencies.aws-smithy-http]
 path = "../aws-smithy-http"
 features = ["event-stream"]
 version = "0.63.6"
-43
 [dependencies.aws-smithy-json]

 path = "../aws-smithy-json"
 version = "0.62.6"
-47
 [dependencies.aws-smithy-observability]
 path = "../aws-smithy-observability"
 version = "0.2.6"
-51
 [dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["client", "http-auth"]
 version = "1.10.3"
 version = "1.10.4"
-56
 [dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["client", "http-1x", "http-auth"]
 version = "1.11.6"
 version = "1.11.7"
-61
 [dependencies.aws-smithy-schema]
 path = "../aws-smithy-schema"
 version = "1.0.0"
-65
 [dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x"]
 version = "1.4.7"
-70

↧ Expand context

 [dependencies.aws-types]
 path = "../aws-types"
 version = "1.4.0"
-74
 [dependencies.bytes]
 version = "1.4.0"
-77
 [dependencies.fastrand]
 version = "2.0.0"
-80
 [dependencies.http]
 version = "0.2.9"
-83
 [dependencies.http-1x]
 version = "1"
 package = "http"
-87
 [dependencies.http-body-util]
 version = "0.1.3"
-90

@@ -102,102 +167,167 @@

↥ Expand context

 features = ["test-util"]
 version = "1.2.14"
-104
 [dev-dependencies.aws-runtime]
 path = "../aws-runtime"
 features = ["test-util"]
 version = "1.7.3"
-109
 [dev-dependencies.aws-smithy-async]
 path = "../aws-smithy-async"
 features = ["test-util"]
 version = "1.2.14"
-114
 [dev-dependencies.aws-smithy-eventstream]
 path = "../aws-smithy-eventstream"
 features = ["test-util"]
 version = "0.60.20"
-119
 [dev-dependencies.aws-smithy-http-client]
 path = "../aws-smithy-http-client"

 features = ["test-util", "wire-mock"]
 version = "1.1.12"
-124
 [dev-dependencies.aws-smithy-protocol-test]
 path = "../aws-smithy-protocol-test"
 version = "0.63.14"
-128
 [dev-dependencies.aws-smithy-runtime]
 path = "../aws-smithy-runtime"
 features = ["test-util"]
 version = "1.10.3"
 version = "1.10.4"
-133
 [dev-dependencies.aws-smithy-runtime-api]
 path = "../aws-smithy-runtime-api"
 features = ["test-util"]
 version = "1.11.6"
 version = "1.11.7"
-138
 [dev-dependencies.aws-smithy-types]
 path = "../aws-smithy-types"
 features = ["http-body-1-x", "test-util"]
 version = "1.4.7"
-143
 [dev-dependencies.futures-util]
 version = "0.3.25"
 features = ["alloc"]
 default-features = false

↧ Expand context

-148
 [dev-dependencies.proptest]
 version = "1"
-151
 [dev-dependencies.serde_json]
 version = "1.0.0"
-154
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
-158
 [dev-dependencies.tracing-subscriber]
 version = "0.3.16"
 features = ["env-filter", "json"]
-162
 [features]
 behavior-version-latest = []
 rustls = ["aws-smithy-runtime/tls-rustls"]
 default-https-client = ["aws-smithy-runtime/default-https-client"]
 rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/config.rs

@@ -23,23 +82,86 @@

↥ Expand context

     pub(crate) config: crate::config::FrozenLayer,
     cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-28
+}
 impl Config {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     pub fn builder() -> Builder {
         Builder::default()
-39
+    }
     /// Converts this config back into a builder so that it can be tweaked.
     pub fn to_builder(&self) -> Builder {
         Builder {

             config: self.cloneable.clone(),
             runtime_components: self.runtime_components.clone(),
             runtime_plugins: self.runtime_plugins.clone(),
             behavior_version: self.behavior_version,
-47
+        }
-48
+    }
     /// Return a reference to the stalled stream protection configuration contained in this config, if any.
     pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
         self.config.load::<crate::config::StalledStreamProtectionConfig>()
-52
+    }
     /// Returns the client protocol used for serialization and deserialization.
     pub fn protocol(&self) -> ::std::option::Option<&::aws_smithy_schema::protocol::SharedClientProtocol> {
         self.config.load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
-+
+    }
     /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
     pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
         self.runtime_components.http_client()
-60
+    }
     /// Return the auth schemes configured on this service config
     pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
         self.runtime_components.auth_schemes()
-64
+    }
-65
     /// Return the auth scheme resolver configured on this service config

↧ Expand context

     pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
         self.runtime_components.auth_scheme_option_resolver()
-69
+    }
     /// Returns the configured auth scheme preference
     pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
         self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
-73
+    }
     /// Returns the endpoint resolver.
     pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
         self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
-77
+    }
     /// Return a reference to the retry configuration contained in this config, if any.
     pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
         self.config.load::<::aws_smithy_types::retry::RetryConfig>()
-81
+    }
-82
     /// Return a cloned shared async sleep implementation from this config, if any.
     pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
         self.runtime_components.sleep_impl()
-86
+    }

@@ -153,157 +254,277 @@

↥ Expand context

     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
-159
+}
 impl ::std::default::Default for Builder {
     fn default() -> Self {
         Self {
             config: ::std::default::Default::default(),
             runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
             runtime_plugins: ::std::default::Default::default(),
             behavior_version: ::std::default::Default::default(),
-167
+        }
-168
+    }
-169
+}
 impl Builder {
     ///
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>

     ///
     pub fn new() -> Self {
         Self::default()
-180
+    }
     /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// but not those in runtime components.
     #[allow(unused)]
     pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
         let mut builder = Self::new();
         builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         if let ::std::option::Option::Some(protocol) = config_bag.load::<::aws_smithy_schema::protocol::SharedClientProtocol>().cloned() {
             builder.set_protocol(::std::option::Option::Some(protocol));
-+
+        }
         builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
         builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
         builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
         builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
         builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
         builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
         builder.set_use_dual_stack(config_bag.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0));
         builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
         builder.set_region(config_bag.load::<crate::config::Region>().cloned());
         builder
-200
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
         self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
         self
-206
+    }
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn set_stalled_stream_protection(
         &mut self,
         stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
     ) -> &mut Self {
         self.config.store_or_unset(stalled_stream_protection_config);
         self
-215
+    }
     /// Sets the idempotency token provider to use for service calls that require tokens.
     pub fn idempotency_token_provider(
         mut self,
         idempotency_token_provider: impl ::std::convert::Into<crate::idempotency_token::IdempotencyTokenProvider>,
     ) -> Self {
         self.set_idempotency_token_provider(::std::option::Option::Some(idempotency_token_provider.into()));
         self
-223
+    }
     /// Sets the idempotency token provider to use for service calls that require tokens.
     pub fn set_idempotency_token_provider(
         &mut self,
         idempotency_token_provider: ::std::option::Option<crate::idempotency_token::IdempotencyTokenProvider>,
     ) -> &mut Self {
         self.config.store_or_unset(idempotency_token_provider);
         self
-231
+    }
     /// Sets the client protocol to use for serialization and deserialization.
     ///
     /// This overrides the default protocol determined by the service model,
     /// enabling runtime protocol selection.
     pub fn protocol(mut self, protocol: impl ::aws_smithy_schema::protocol::ClientProtocol + 'static) -> Self {
         self.set_protocol(::std::option::Option::Some(::aws_smithy_schema::protocol::SharedClientProtocol::new(
             protocol,
         )));
         self
-+
+    }
-+
     /// Sets the client protocol to use for serialization and deserialization.
     pub fn set_protocol(&mut self, protocol: ::std::option::Option<::aws_smithy_schema::protocol::SharedClientProtocol>) -> &mut Self {
         self.config.store_or_unset(protocol);
         self
-+
+    }
     /// Sets the HTTP client to use when making requests.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use aws_sdk_bedrockruntime::config::Config;

↧ Expand context

     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///     .with_webpki_roots()
     ///     .https_only()
     ///     .enable_http1()
     ///     .enable_http2()
     ///     .build();
     /// let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///
     /// // This connector can then be given to a generated service Config
     /// let config = my_service_client::Config::builder()
     ///     .endpoint_url("https://example.com")
     ///     .http_client(hyper_client)
     ///     .build();
     /// let client = my_service_client::Client::from_conf(config);
     /// # }
     /// # }
     /// ```
     pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {

@@ -1336,1359 +1395,1423 @@

↥ Expand context

                 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
-1360
+        }
         layer.store_put(crate::meta::API_METADATA.clone());
         layer.store_put(::aws_types::SigningName::from_static("bedrock"));
         layer
             .load::<::aws_types::region::Region>()
             .cloned()
             .map(|r| layer.store_put(::aws_types::region::SigningRegion::from(r)));
         Config {
             config: crate::config::Layer::from(layer.clone())
                 .with_name("aws_sdk_bedrockruntime::config::Config")
                 .freeze(),
             cloneable: layer,
             runtime_components: self.runtime_components,
             runtime_plugins: self.runtime_plugins,
             behavior_version: self.behavior_version,
-1375
+        }
-1376
+    }
-1377
+}
 #[derive(::std::fmt::Debug)]

 pub(crate) struct ServiceRuntimePlugin {
     config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
     runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1382
+}
-1383
 impl ServiceRuntimePlugin {
     pub fn new(_service_config: crate::config::Config) -> Self {
         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("AmazonBedrockFrontendService");
             cfg.store_put(crate::idempotency_token::default_provider());
             if _service_config.protocol().is_none() {
                 cfg.store_put(::aws_smithy_schema::protocol::SharedClientProtocol::new(
                     ::aws_smithy_json::protocol::aws_rest_json_1::AwsRestJsonProtocol::new(),
                 ));
-+
+            }
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(
             ::aws_smithy_runtime::client::auth::http::BearerAuthScheme::new(),
         ));
         runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
             use crate::config::auth::ResolveAuthScheme;
             crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()

↧ Expand context

         }));
         runtime_components.set_endpoint_resolver(::std::option::Option::Some({
             use crate::config::endpoint::ResolveEndpoint;
             crate::config::endpoint::DefaultResolver::new().into_shared_resolver()
         }));
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::service_clock_skew::ServiceClockSkewInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::request_info::RequestInfoInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::user_agent::UserAgentInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::invocation_id::InvocationIdInterceptor::new());
         runtime_components.push_interceptor(::aws_runtime::recursion_detection::RecursionDetectionInterceptor::new());
         runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(
             ::aws_runtime::auth::sigv4::SigV4AuthScheme::new(),
         ));
         runtime_components.push_interceptor(crate::config::endpoint::EndpointOverrideFeatureTrackerInterceptor);
         runtime_components.push_interceptor(crate::observability_feature::ObservabilityFeatureTrackerInterceptor);
         Self { config, runtime_components }
-1423
+    }

@@ -1474,1502 +1533,1564 @@

↥ Expand context

-1502
 impl From<&::aws_types::sdk_config::SdkConfig> for Builder {
     fn from(input: &::aws_types::sdk_config::SdkConfig) -> Self {
         let mut builder = Builder::default();
         builder.set_credentials_provider(input.credentials_provider());
         builder = builder.region(input.region().cloned());
         builder.set_use_fips(input.use_fips());
         builder.set_use_dual_stack(input.use_dual_stack());
         if input.get_origin("endpoint_url").is_client_config() {
             builder.set_endpoint_url(input.endpoint_url().map(|s| s.to_string()));
         } else {
             builder.set_endpoint_url(
                 input
                     .service_config()
                     .and_then(|conf| {
                         conf.load_config(service_config_key("Bedrock Runtime", "AWS_ENDPOINT_URL", "endpoint_url"))
                             .map(|it| it.parse().unwrap())
                     })
                     .or_else(|| input.endpoint_url().map(|s| s.to_string())),
             );

-1522
+        }
         // resiliency
         builder.set_retry_config(input.retry_config().cloned());
         builder.set_timeout_config(input.timeout_config().cloned());
         builder.set_sleep_impl(input.sleep_impl());
-1527
         builder.set_http_client(input.http_client());
         builder.set_time_source(input.time_source());
         builder.set_behavior_version(input.behavior_version());
         builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
         if let Some(protocol) = input.protocol() {
             builder.set_protocol(Some(protocol.clone()));
-+
+        }
         // setting `None` here removes the default
         if let Some(config) = input.stalled_stream_protection() {
             builder.set_stalled_stream_protection(Some(config));
-1538
+        }
-1539
         if let Some(cache) = input.identity_cache() {
             builder.set_identity_cache(cache);
-1542
+        }
         builder.set_token_provider(input.token_provider());
         if let ::std::option::Option::Some(val) = input.service_config().and_then(|conf| {

↧ Expand context

             // Passing an empty string for the last argument of `service_config_key`,
             // since shared config/profile for environment token provider is not supported.
             ::aws_types::service_config::LoadServiceConfig::load_config(conf, service_config_key("bedrock", "AWS_BEARER_TOKEN", ""))
                 .and_then(|it| it.parse::<::std::string::String>().ok())
         }) {
             if !input.get_origin("auth_scheme_preference").is_client_config() {
                 builder.set_auth_scheme_preference(::std::option::Option::Some(
                     [::aws_smithy_runtime_api::client::auth::http::HTTP_BEARER_AUTH_SCHEME_ID].into(),
                 ));
-1554
+            }
             if !input.get_origin("token_provider").is_client_config() {
                 let mut layer = ::aws_smithy_types::config_bag::Layer::new("AwsBearerTokenBedrock");
                 layer.store_append(::aws_credential_types::credential_feature::AwsCredentialFeature::BearerServiceEnvVars);
                 let identity = ::aws_smithy_runtime_api::client::identity::Identity::builder()
                     .data(crate::config::Token::new(val, ::std::option::Option::None))
                     .property(layer.freeze())
                     .build()
                     .expect("required fields set");
                 builder
                     .runtime_components

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/lib.rs

@@ -176,176 +217,215 @@

↥ Expand context

 pub mod error;
-177
 mod error_meta;
-179
 /// Information about this crate.
 pub mod meta;
-182
 /// All operations that this crate can perform.
 pub mod operation;
-185
 /// Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-188
 /// Data structures used by operation inputs/outputs.
 pub mod types;
-191
 pub(crate) mod client_idempotency_token;
-193
 mod event_receiver;
-195

 mod event_stream_serde;
-197
 mod idempotency_token;
-199
 mod observability_feature;
-201
 pub(crate) mod protocol_serde;
-203
 mod sdk_feature_tracker;
-205
 mod serialization_settings;
--
 mod endpoint_lib;
-207
 mod json_errors;
-+
 mod lens;
-211
 mod serde_util;
-213
 mod json_errors;
--
 #[doc(inline)]
 pub use client::Client;

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

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

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

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::apply_guardrail::ApplyGuardrailError>()
                     .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::apply_guardrail::ApplyGuardrailOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -119,123 +269,470 @@

↥ Expand context

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

                 crate::operation::apply_guardrail::ApplyGuardrailError,
             >::new());
-145
         ::std::borrow::Cow::Owned(rcb)
-147
+    }
-148
+}
-149
 #[derive(Debug)]
 struct ApplyGuardrailResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ApplyGuardrailResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_apply_guardrail::de_apply_guardrail_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_apply_guardrail::de_apply_guardrail_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::apply_guardrail::ApplyGuardrailError::unhandled(
                             generic,
                         )),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "AccessDeniedException" => crate::operation::apply_guardrail::ApplyGuardrailError::AccessDeniedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerException" => crate::operation::apply_guardrail::ApplyGuardrailError::InternalServerException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::apply_guardrail::ApplyGuardrailError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceQuotaExceededException" => crate::operation::apply_guardrail::ApplyGuardrailError::ServiceQuotaExceededException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceQuotaExceededException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceQuotaExceededException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::apply_guardrail::ApplyGuardrailError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ThrottlingException" => crate::operation::apply_guardrail::ApplyGuardrailError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ValidationException" => crate::operation::apply_guardrail::ApplyGuardrailError::ValidationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::apply_guardrail::ApplyGuardrailError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ApplyGuardrail::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::apply_guardrail::ApplyGuardrailOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-380
+    }
-381
+}
 #[derive(Debug)]
 struct ApplyGuardrailRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ApplyGuardrailRequestSerializer {
     #[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::apply_guardrail::ApplyGuardrailInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::apply_guardrail::ApplyGuardrailInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.guardrail_identifier;
                 let input_1 = input_1.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("guardrail_identifier", "cannot be empty or unset")
                 })?;
                 let guardrail_identifier = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if guardrail_identifier.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "guardrail_identifier",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_2 = &_input.guardrail_version;
                 let input_2 = input_2.as_ref().ok_or_else(|| {
                     ::aws_smithy_types::error::operation::BuildError::missing_field("guardrail_version", "cannot be empty or unset")
                 })?;
                 let guardrail_version = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if guardrail_version.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "guardrail_version",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(
                     output,
                     "/guardrail/{guardrailIdentifier}/version/{guardrailVersion}/apply",
                     guardrailIdentifier = guardrail_identifier,
                     guardrailVersion = guardrail_version
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, ApplyGuardrail::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/guardrail/{guardrailIdentifier}/version/{guardrailVersion}/apply".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.guardrail_identifier {
                     uri = uri.replace(
                         "{guardrailIdentifier}",
                         &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()),
                     );
-+
+                }
                 if let Some(ref val) = input.guardrail_version {
                     uri = uri.replace(
                         "{guardrailVersion}",
                         &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()),
                     );
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-425
+                            )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-429
+                }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::apply_guardrail::ApplyGuardrailInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_apply_guardrail::ser_apply_guardrail_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
                 request.set_uri(uri.as_str()).expect("valid URI");
-+
+            }
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, ApplyGuardrail::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-440
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-441
+    }
-442
+}
 #[derive(Debug)]
 struct ApplyGuardrailEndpointParamsInterceptor;
-445
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ApplyGuardrailEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ApplyGuardrailEndpointParamsInterceptor"
-449
+    }
-450

↧ Expand context

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

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

@@ -25,25 +226,242 @@

↥ Expand context

         self.guardrail_version.as_deref()
-26
+    }
     /// <p>The source of data used in the request to apply the guardrail.</p>
     pub fn source(&self) -> ::std::option::Option<&crate::types::GuardrailContentSource> {
         self.source.as_ref()
-30
+    }
     /// <p>The content details used in the request to apply the guardrail.</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 `.content.is_none()`.
     pub fn content(&self) -> &[crate::types::GuardrailContentBlock] {
         self.content.as_deref().unwrap_or_default()
-36
+    }
     /// <p>Specifies the scope of the output that you get in the response. Set to <code>FULL</code> to return the entire output, including any detected and non-detected entries in the response for enhanced debugging.</p>
     /// <p>Note that the full output scope doesn't apply to word filters or regex in sensitive information filters. It does apply to all other filtering policies, including sensitive information with filters that can detect personally identifiable information (PII).</p>
     pub fn output_scope(&self) -> ::std::option::Option<&crate::types::GuardrailOutputScope> {
         self.output_scope.as_ref()
-41
+    }
-42
+}
 static APPLYGUARDRAILINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailInput",

     "com.amazonaws.bedrockruntime.synthetic",
     "ApplyGuardrailInput",
 );
 static APPLYGUARDRAILINPUT_MEMBER_GUARDRAIL_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailInput$guardrailIdentifier",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "guardrail_identifier",
     "guardrailIdentifier",
 ,
-57
+)
 .with_http_label();
 static APPLYGUARDRAILINPUT_MEMBER_GUARDRAIL_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailInput$guardrailVersion",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "guardrail_version",
     "guardrailVersion",
 ,
-68
+)
 .with_http_label();
 static APPLYGUARDRAILINPUT_MEMBER_SOURCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailInput$source",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "source",
 ,
 );
 static APPLYGUARDRAILINPUT_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailInput$content",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "content",
 ,
 );
 static APPLYGUARDRAILINPUT_MEMBER_OUTPUT_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailInput$outputScope",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "output_scope",
     "outputScope",
 ,
 );
 static APPLYGUARDRAILINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     APPLYGUARDRAILINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &APPLYGUARDRAILINPUT_MEMBER_GUARDRAIL_IDENTIFIER,
         &APPLYGUARDRAILINPUT_MEMBER_GUARDRAIL_VERSION,
         &APPLYGUARDRAILINPUT_MEMBER_SOURCE,
         &APPLYGUARDRAILINPUT_MEMBER_CONTENT,
         &APPLYGUARDRAILINPUT_MEMBER_OUTPUT_SCOPE,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/guardrail/{guardrailIdentifier}/version/{guardrailVersion}/apply",
     None,
 ));
 impl ApplyGuardrailInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &APPLYGUARDRAILINPUT_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ApplyGuardrailInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.guardrail_identifier {
             ser.write_string(&APPLYGUARDRAILINPUT_MEMBER_GUARDRAIL_IDENTIFIER, val)?;
-128
+        }
         if let Some(ref val) = self.guardrail_version {
             ser.write_string(&APPLYGUARDRAILINPUT_MEMBER_GUARDRAIL_VERSION, val)?;
-131
+        }
         if let Some(ref val) = self.source {
             ser.write_string(&APPLYGUARDRAILINPUT_MEMBER_SOURCE, val.as_str())?;
-134
+        }
         if let Some(ref val) = self.content {
             ser.write_list(
                 &APPLYGUARDRAILINPUT_MEMBER_CONTENT,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_struct(crate::types::GuardrailContentBlock::SCHEMA, item)?;
-141
+                    }
                     Ok(())
                 },
             )?;
-145
+        }
         if let Some(ref val) = self.output_scope {
             ser.write_string(&APPLYGUARDRAILINPUT_MEMBER_OUTPUT_SCOPE, val.as_str())?;
-148
+        }
         Ok(())
-150
+    }
-151
+}
 impl ApplyGuardrailInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&APPLYGUARDRAILINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&APPLYGUARDRAILINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.guardrail_identifier = Some(deser.read_string(member)?);
-170
+                }
                 Some(1) => {
                     builder.guardrail_version = Some(deser.read_string(member)?);
-173
+                }
                 Some(2) => {
                     builder.source = Some(crate::types::GuardrailContentSource::from(deser.read_string(member)?.as_str()));
-176
+                }
                 Some(3) => {
                     builder.content = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GuardrailContentBlock::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-186
+                }
                 Some(4) => {
                     builder.output_scope = Some(crate::types::GuardrailOutputScope::from(deser.read_string(member)?.as_str()));
-189
+                }
                 _ => {}
-191
+            }
             Ok(())
         })?;
         builder.guardrail_identifier = builder.guardrail_identifier.or(Some(String::new()));
         builder.guardrail_version = builder.guardrail_version.or(Some(String::new()));
         builder.content = builder.content.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-200
+    }
-201
+}
 impl ApplyGuardrailInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ApplyGuardrailInput {
     /// Creates a new builder-style object to manufacture [`ApplyGuardrailInput`](crate::operation::apply_guardrail::ApplyGuardrailInput).
     pub fn builder() -> crate::operation::apply_guardrail::builders::ApplyGuardrailInputBuilder {
         crate::operation::apply_guardrail::builders::ApplyGuardrailInputBuilder::default()
-217
+    }
-218
+}
-219
 /// A builder for [`ApplyGuardrailInput`](crate::operation::apply_guardrail::ApplyGuardrailInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ApplyGuardrailInputBuilder {
     pub(crate) guardrail_identifier: ::std::option::Option<::std::string::String>,
     pub(crate) guardrail_version: ::std::option::Option<::std::string::String>,
     pub(crate) source: ::std::option::Option<crate::types::GuardrailContentSource>,
     pub(crate) content: ::std::option::Option<::std::vec::Vec<crate::types::GuardrailContentBlock>>,
     pub(crate) output_scope: ::std::option::Option<crate::types::GuardrailOutputScope>,
-229
+}
 impl ApplyGuardrailInputBuilder {
     /// <p>The guardrail identifier used in the request to apply the guardrail.</p>
     /// This field is required.
     pub fn guardrail_identifier(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.guardrail_identifier = ::std::option::Option::Some(input.into());
         self
-236
+    }
     /// <p>The guardrail identifier used in the request to apply the guardrail.</p>
     pub fn set_guardrail_identifier(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.guardrail_identifier = input;
         self
-241
+    }
     /// <p>The guardrail identifier used in the request to apply the guardrail.</p>

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

@@ -50,50 +255,327 @@

↥ Expand context

     "com.amazonaws.bedrockruntime.synthetic",
     "ApplyGuardrailOutput",
 );
 static APPLYGUARDRAILOUTPUT_MEMBER_USAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailOutput$usage",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "usage",
 ,
 );
 static APPLYGUARDRAILOUTPUT_MEMBER_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailOutput$action",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,

     "action",
 ,
 );
 static APPLYGUARDRAILOUTPUT_MEMBER_ACTION_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailOutput$actionReason",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "action_reason",
     "actionReason",
 ,
 );
 static APPLYGUARDRAILOUTPUT_MEMBER_OUTPUTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailOutput$outputs",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "outputs",
 ,
 );
 static APPLYGUARDRAILOUTPUT_MEMBER_ASSESSMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailOutput$assessments",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "assessments",
 ,
 );
 static APPLYGUARDRAILOUTPUT_MEMBER_GUARDRAIL_COVERAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ApplyGuardrailOutput$guardrailCoverage",
         "com.amazonaws.bedrockruntime.synthetic",
         "ApplyGuardrailOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "guardrail_coverage",
     "guardrailCoverage",
 ,
 );
 static APPLYGUARDRAILOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static APPLYGUARDRAILOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     APPLYGUARDRAILOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &APPLYGUARDRAILOUTPUT_MEMBER_USAGE,
         &APPLYGUARDRAILOUTPUT_MEMBER_ACTION,
         &APPLYGUARDRAILOUTPUT_MEMBER_ACTION_REASON,
         &APPLYGUARDRAILOUTPUT_MEMBER_OUTPUTS,
         &APPLYGUARDRAILOUTPUT_MEMBER_ASSESSMENTS,
         &APPLYGUARDRAILOUTPUT_MEMBER_GUARDRAIL_COVERAGE,
         &APPLYGUARDRAILOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ApplyGuardrailOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &APPLYGUARDRAILOUTPUT_SCHEMA;
-136
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ApplyGuardrailOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.usage {
             ser.write_struct(&APPLYGUARDRAILOUTPUT_MEMBER_USAGE, val)?;
-145
+        }
-146
+        {
             let val = &self.action;
             ser.write_string(&APPLYGUARDRAILOUTPUT_MEMBER_ACTION, val.as_str())?;
-149
+        }
         if let Some(ref val) = self.action_reason {
             ser.write_string(&APPLYGUARDRAILOUTPUT_MEMBER_ACTION_REASON, val)?;
-152
+        }
-153
+        {
             let val = &self.outputs;
-155
             ser.write_list(
                 &APPLYGUARDRAILOUTPUT_MEMBER_OUTPUTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GuardrailOutputContent::SCHEMA, item)?;
-161
+                    }
                     Ok(())
                 },
             )?;
-165
+        }
-166
+        {
             let val = &self.assessments;
-168
             ser.write_list(
                 &APPLYGUARDRAILOUTPUT_MEMBER_ASSESSMENTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::GuardrailAssessment::SCHEMA, item)?;
-174
+                    }
                     Ok(())
                 },
             )?;
-178
+        }
         if let Some(ref val) = self.guardrail_coverage {
             ser.write_struct(&APPLYGUARDRAILOUTPUT_MEMBER_GUARDRAIL_COVERAGE, val)?;
-181
+        }
         Ok(())
-183
+    }
-184
+}
 impl ApplyGuardrailOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&APPLYGUARDRAILOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.usage = Some(crate::types::GuardrailUsage::deserialize(deser)?);
-+
+                }
                 Some(1) => {
                     builder.action = Some(crate::types::GuardrailAction::from(deser.read_string(member)?.as_str()));
-+
+                }
                 Some(2) => {
                     builder.action_reason = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.outputs = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GuardrailOutputContent::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(4) => {
                     builder.assessments = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GuardrailAssessment::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(5) => {
                     builder.guardrail_coverage = Some(crate::types::GuardrailCoverage::deserialize(deser)?);
-+
+                }
                 Some(6) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder.outputs = builder.outputs.or(Some(Vec::new()));
         builder.assessments = builder.assessments.or(Some(Vec::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl ApplyGuardrailOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&APPLYGUARDRAILOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&APPLYGUARDRAILOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.usage = Some(crate::types::GuardrailUsage::deserialize(deser)?);
-273
+                }
                 Some(1) => {
                     builder.action = Some(crate::types::GuardrailAction::from(deser.read_string(member)?.as_str()));
-276
+                }
                 Some(2) => {
                     builder.action_reason = Some(deser.read_string(member)?);
-279
+                }
                 Some(3) => {
                     builder.outputs = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::GuardrailOutputContent::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GuardrailOutputContent::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-289
+                }
                 Some(4) => {
                     builder.assessments = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::GuardrailAssessment::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::GuardrailAssessment::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-299
+                }
                 Some(5) => {
                     builder.guardrail_coverage = Some(crate::types::GuardrailCoverage::deserialize(deser)?);
-302
+                }
                 _ => {}
-304
+            }
             Ok(())
         })?;
         builder

↧ Expand context

             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-310
+    }
-311
+}
 impl ::aws_types::request_id::RequestId for ApplyGuardrailOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-315
+    }
-316
+}
 impl ApplyGuardrailOutput {
     /// Creates a new builder-style object to manufacture [`ApplyGuardrailOutput`](crate::operation::apply_guardrail::ApplyGuardrailOutput).
     pub fn builder() -> crate::operation::apply_guardrail::builders::ApplyGuardrailOutputBuilder {
         crate::operation::apply_guardrail::builders::ApplyGuardrailOutputBuilder::default()
-321
+    }
-322
+}
-323
 /// A builder for [`ApplyGuardrailOutput`](crate::operation::apply_guardrail::ApplyGuardrailOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ApplyGuardrailOutputBuilder {

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

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

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

↧ Expand context

         let map_err =
             |err: ::aws_smithy_runtime_api::client::result::SdkError<
                 ::aws_smithy_runtime_api::client::interceptors::context::Error,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
             >| { err.map_service_error(|err| err.downcast::<crate::operation::converse::ConverseError>().expect("correct error type")) };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::converse::ConverseOutput>()
                 .expect("correct output type"),
-38
+        )
-39
+    }
-40
     pub(crate) async fn orchestrate_with_stop_point(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::converse::ConverseInput,
         stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,

@@ -115,119 +246,499 @@

↥ Expand context

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

                 crate::operation::converse::ConverseError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct ConverseResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ConverseResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_converse::de_converse_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_converse::de_converse_http_response(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::converse::ConverseError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "AccessDeniedException" => crate::operation::converse::ConverseError::AccessDeniedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "InternalServerException" => crate::operation::converse::ConverseError::InternalServerException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ModelErrorException" => crate::operation::converse::ConverseError::ModelErrorException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ModelErrorException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ModelErrorException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ModelNotReadyException" => crate::operation::converse::ConverseError::ModelNotReadyException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ModelNotReadyException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ModelNotReadyException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ModelTimeoutException" => crate::operation::converse::ConverseError::ModelTimeoutException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ModelTimeoutException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ModelTimeoutException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::converse::ConverseError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::converse::ConverseError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ThrottlingException" => crate::operation::converse::ConverseError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ValidationException" => crate::operation::converse::ConverseError::ValidationException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::converse::ConverseError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, Converse::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::converse::ConverseOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-420
+    }
-421
+}
 #[derive(Debug)]
 struct ConverseRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ConverseRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::converse::ConverseInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::converse::ConverseInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.model_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("model_id", "cannot be empty or unset"))?;
                 let model_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if model_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "model_id",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_body(&input, Converse::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/model/{modelId}/converse".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.model_id {
                     uri = uri.replace("{modelId}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-+
+                }
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-458
+                }
                 ::std::write!(output, "/model/{modelId}/converse", modelId = model_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
                 request.set_uri(uri.as_str()).expect("valid URI");
-460
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::converse::ConverseInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_converse::ser_converse_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, Converse::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-469
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-470
+    }
-471
+}
 #[derive(Debug)]
 struct ConverseEndpointParamsInterceptor;
-474
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ConverseEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ConverseEndpointParamsInterceptor"
-478
+    }
-479

↧ Expand context

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

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

@@ -114,114 +490,474 @@

↥ Expand context

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

     "com.amazonaws.bedrockruntime.synthetic",
     "ConverseInput",
 );
 static CONVERSEINPUT_MEMBER_MODEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$modelId",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "model_id",
     "modelId",
 ,
-146
+)
 .with_http_label();
 static CONVERSEINPUT_MEMBER_MESSAGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$messages",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "messages",
 ,
 );
 static CONVERSEINPUT_MEMBER_SYSTEM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$system",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "system",
 ,
 );
 static CONVERSEINPUT_MEMBER_INFERENCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$inferenceConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "inference_config",
     "inferenceConfig",
 ,
 );
 static CONVERSEINPUT_MEMBER_TOOL_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$toolConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "tool_config",
     "toolConfig",
 ,
 );
 static CONVERSEINPUT_MEMBER_GUARDRAIL_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$guardrailConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "guardrail_config",
     "guardrailConfig",
 ,
 );
 static CONVERSEINPUT_MEMBER_ADDITIONAL_MODEL_REQUEST_FIELDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$additionalModelRequestFields",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::Document,
     "additional_model_request_fields",
     "additionalModelRequestFields",
 ,
 );
 static CONVERSEINPUT_MEMBER_PROMPT_VARIABLES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$promptVariables",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "prompt_variables",
     "promptVariables",
 ,
 );
 static CONVERSEINPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$additionalModelResponseFieldPaths",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "additional_model_response_field_paths",
     "additionalModelResponseFieldPaths",
 ,
 );
 static CONVERSEINPUT_MEMBER_REQUEST_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$requestMetadata",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "request_metadata",
     "requestMetadata",
 ,
 );
 static CONVERSEINPUT_MEMBER_PERFORMANCE_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.bedrockruntime.synthetic#ConverseInput$performanceConfig",
         "com.amazonaws.bedrockruntime.synthetic",
         "ConverseInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "performance_config",
     "performanceConfig",
 ,
 );
 static CONVERSEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     CONVERSEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &CONVERSEINPUT_MEMBER_MODEL_ID,
         &CONVERSEINPUT_MEMBER_MESSAGES,
         &CONVERSEINPUT_MEMBER_SYSTEM,
         &CONVERSEINPUT_MEMBER_INFERENCE_CONFIG,
         &CONVERSEINPUT_MEMBER_TOOL_CONFIG,
         &CONVERSEINPUT_MEMBER_GUARDRAIL_CONFIG,
         &CONVERSEINPUT_MEMBER_ADDITIONAL_MODEL_REQUEST_FIELDS,
         &CONVERSEINPUT_MEMBER_PROMPT_VARIABLES,
         &CONVERSEINPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS,
         &CONVERSEINPUT_MEMBER_REQUEST_METADATA,
         &CONVERSEINPUT_MEMBER_PERFORMANCE_CONFIG,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/model/{modelId}/converse", None));
 impl ConverseInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CONVERSEINPUT_SCHEMA;
-269
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ConverseInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.model_id {
             ser.write_string(&CONVERSEINPUT_MEMBER_MODEL_ID, val)?;
-278
+        }
         if let Some(ref val) = self.messages {
             ser.write_list(
                 &CONVERSEINPUT_MEMBER_MESSAGES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Message::SCHEMA, item)?;
-285
+                    }
                     Ok(())
                 },
             )?;
-289
+        }
         if let Some(ref val) = self.system {
             ser.write_list(
                 &CONVERSEINPUT_MEMBER_SYSTEM,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         todo!("schema: unsupported list element type");
                         ser.write_struct(crate::types::SystemContentBlock::SCHEMA, item)?;
-296
+                    }
                     Ok(())
                 },
             )?;
-300
+        }
         if let Some(ref val) = self.inference_config {
             ser.write_struct(&CONVERSEINPUT_MEMBER_INFERENCE_CONFIG, val)?;
-303
+        }
         if let Some(ref val) = self.tool_config {
             ser.write_struct(&CONVERSEINPUT_MEMBER_TOOL_CONFIG, val)?;
-306
+        }
         if let Some(ref val) = self.guardrail_config {
             ser.write_struct(&CONVERSEINPUT_MEMBER_GUARDRAIL_CONFIG, val)?;
-309
+        }
         if let Some(ref val) = self.additional_model_request_fields {
             ser.write_document(&CONVERSEINPUT_MEMBER_ADDITIONAL_MODEL_REQUEST_FIELDS, val)?;
-312
+        }
         if let Some(ref val) = self.prompt_variables {
             ser.write_map(
                 &CONVERSEINPUT_MEMBER_PROMPT_VARIABLES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
                         ser.write_struct(crate::types::PromptVariableValues::SCHEMA, value)?;
-320
+                    }
                     Ok(())
                 },
             )?;
-324
+        }
         if let Some(ref val) = self.additional_model_response_field_paths {
             ser.write_list(
                 &CONVERSEINPUT_MEMBER_ADDITIONAL_MODEL_RESPONSE_FIELD_PATHS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
-331
+                    }
                     Ok(())
                 },
             )?;
-335
+        }
         if let Some(ref val) = self.request_metadata {
             ser.write_map(
                 &CONVERSEINPUT_MEMBER_REQUEST_METADATA,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-343
+                    }
                     Ok(())
                 },
             )?;
-347
+        }
         if let Some(ref val) = self.performance_config {
             ser.write_struct(&CONVERSEINPUT_MEMBER_PERFORMANCE_CONFIG, val)?;
-350
+        }
         Ok(())
-352
+    }
-353
+}
 impl ConverseInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&CONVERSEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&CONVERSEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.model_id = Some(deser.read_string(member)?);
-372
+                }
                 Some(1) => {
                     builder.messages = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::Message::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Message::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-382
+                }
                 Some(2) => {
                     builder.system = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(todo!("deserialize nested aggregate"));
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::SystemContentBlock::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-392
+                }
                 Some(3) => {
                     builder.inference_config = Some(crate::types::InferenceConfiguration::deserialize(deser)?);
-395
+                }
                 Some(4) => {
                     builder.tool_config = Some(crate::types::ToolConfiguration::deserialize(deser)?);
-398
+                }
                 Some(5) => {
                     builder.guardrail_config = Some(crate::types::GuardrailConfiguration::deserialize(deser)?);
-401
+                }
                 Some(6) => {
                     builder.additional_model_request_fields = Some(deser.read_document(member)?);
-404
+                }
                 Some(7) => {
                     builder.prompt_variables = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::PromptVariableValues::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-414
+                }
                 Some(8) => {
                     builder.additional_model_response_field_paths = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(deser.read_string(member)?);
                             Ok(list)
                         })?
                     });
                     builder.additional_model_response_field_paths = Some(deser.read_string_list(member)?);
-417
+                }
                 Some(9) => {
                     builder.request_metadata = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.request_metadata = Some(deser.read_string_string_map(member)?);
-420
+                }
                 Some(10) => {
                     builder.performance_config = Some(crate::types::PerformanceConfiguration::deserialize(deser)?);
-423
+                }
                 _ => {}
-425
+            }
             Ok(())
         })?;
         builder.model_id = builder.model_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-432
+    }
-433
+}
 impl ConverseInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl ConverseInput {
     /// Creates a new builder-style object to manufacture [`ConverseInput`](crate::operation::converse::ConverseInput).
     pub fn builder() -> crate::operation::converse::builders::ConverseInputBuilder {
         crate::operation::converse::builders::ConverseInputBuilder::default()
-449
+    }
-450
+}
-451
 /// A builder for [`ConverseInput`](crate::operation::converse::ConverseInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct ConverseInputBuilder {
     pub(crate) model_id: ::std::option::Option<::std::string::String>,
     pub(crate) messages: ::std::option::Option<::std::vec::Vec<crate::types::Message>>,
     pub(crate) system: ::std::option::Option<::std::vec::Vec<crate::types::SystemContentBlock>>,
     pub(crate) inference_config: ::std::option::Option<crate::types::InferenceConfiguration>,
     pub(crate) tool_config: ::std::option::Option<crate::types::ToolConfiguration>,
     pub(crate) guardrail_config: ::std::option::Option<crate::types::GuardrailConfiguration>,
     pub(crate) additional_model_request_fields: ::std::option::Option<::aws_smithy_types::Document>,
     pub(crate) prompt_variables: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::PromptVariableValues>>,
     pub(crate) additional_model_response_field_paths: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
     pub(crate) request_metadata: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     pub(crate) performance_config: ::std::option::Option<crate::types::PerformanceConfiguration>,
-467
+}
 impl ConverseInputBuilder {
     /// <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>

 allowed_external_types = [
     "aws_credential_types::provider::credentials::SharedCredentialsProvider",
     "aws_credential_types::provider::token::SharedTokenProvider",
     "aws_smithy_async::rt::sleep::AsyncSleep",

     "aws_smithy_async::rt::sleep::SharedAsyncSleep",
     "aws_smithy_async::time::SharedTimeSource",
     "aws_smithy_async::time::TimeSource",
     "aws_smithy_runtime_api::client::auth::AuthSchemePreference",
     "aws_smithy_runtime_api::client::behavior_version::BehaviorVersion",
     "aws_smithy_runtime_api::client::http::HttpClient",
     "aws_smithy_runtime_api::client::http::SharedHttpClient",
     "aws_smithy_runtime_api::client::identity::ResolveCachedIdentity",
     "aws_smithy_runtime_api::client::identity::SharedIdentityCache",
     "aws_smithy_runtime_api::client::stalled_stream_protection::StalledStreamProtectionConfig",
     "aws_smithy_schema::schema::protocol::ClientProtocol",
     "aws_smithy_schema::schema::protocol::SharedClientProtocol",
     "aws_smithy_runtime_api::http::headers::Headers",
     "aws_smithy_types::checksum_config::ResponseChecksumValidation",
     "aws_smithy_types::checksum_config::RequestChecksumCalculation",
     "aws_smithy_types::config_bag::storable::Storable",
     "aws_smithy_types::config_bag::storable::StoreReplace",
     "aws_smithy_types::error::metadata::Builder",
     "aws_smithy_types::retry::RetryConfig",
     "aws_smithy_types::timeout::TimeoutConfig",
-25
+]

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-wasm/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-types/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/aws-types/external-types.toml

tmp-codegen-diff/aws-sdk/sdk/aws-types/src/sdk_config.rs

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/Cargo.toml

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/config.rs

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/lib.rs

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

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

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

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

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