AWS SDK

rev. ba98f30b52e51c6e715b0ae469e7a2e988c27d9a (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_content_filter_type.rs

@@ -1,0 +132,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// When writing a match expression against `GuardrailContentFilterType`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let guardrailcontentfiltertype = unimplemented!();
 /// match guardrailcontentfiltertype {
 ///     GuardrailContentFilterType::Hate => { /* ... */ },
 ///     GuardrailContentFilterType::Insults => { /* ... */ },
 ///     GuardrailContentFilterType::Misconduct => { /* ... */ },
 ///     GuardrailContentFilterType::PromptAttack => { /* ... */ },
 ///     GuardrailContentFilterType::Sexual => { /* ... */ },
 ///     GuardrailContentFilterType::Violence => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `guardrailcontentfiltertype` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `GuardrailContentFilterType::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `GuardrailContentFilterType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `GuardrailContentFilterType::NewFeature` is defined.
 /// Specifically, when `guardrailcontentfiltertype` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `GuardrailContentFilterType::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum GuardrailContentFilterType {
     #[allow(missing_docs)] // documentation missing in model
     Hate,
     #[allow(missing_docs)] // documentation missing in model
     Insults,
     #[allow(missing_docs)] // documentation missing in model
     Misconduct,
     #[allow(missing_docs)] // documentation missing in model
     PromptAttack,
     #[allow(missing_docs)] // documentation missing in model
     Sexual,
     #[allow(missing_docs)] // documentation missing in model
     Violence,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
--
+}
 impl ::std::convert::From<&str> for GuardrailContentFilterType {
     fn from(s: &str) -> Self {
         match s {
             "HATE" => GuardrailContentFilterType::Hate,
             "INSULTS" => GuardrailContentFilterType::Insults,
             "MISCONDUCT" => GuardrailContentFilterType::Misconduct,
             "PROMPT_ATTACK" => GuardrailContentFilterType::PromptAttack,
             "SEXUAL" => GuardrailContentFilterType::Sexual,
             "VIOLENCE" => GuardrailContentFilterType::Violence,
             other => GuardrailContentFilterType::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
--
+        }
--
+    }
--
+}
 impl ::std::str::FromStr for GuardrailContentFilterType {
     type Err = ::std::convert::Infallible;
--
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(GuardrailContentFilterType::from(s))
--
+    }
--
+}
 impl GuardrailContentFilterType {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             GuardrailContentFilterType::Hate => "HATE",
             GuardrailContentFilterType::Insults => "INSULTS",
             GuardrailContentFilterType::Misconduct => "MISCONDUCT",
             GuardrailContentFilterType::PromptAttack => "PROMPT_ATTACK",
             GuardrailContentFilterType::Sexual => "SEXUAL",
             GuardrailContentFilterType::Violence => "VIOLENCE",
             GuardrailContentFilterType::Unknown(value) => value.as_str(),
--
+        }
--
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["HATE", "INSULTS", "MISCONDUCT", "PROMPT_ATTACK", "SEXUAL", "VIOLENCE"]
--
+    }
--
+}
 impl ::std::convert::AsRef<str> for GuardrailContentFilterType {
     fn as_ref(&self) -> &str {
         self.as_str()
--
+    }
--
+}
 impl GuardrailContentFilterType {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
--
+        }
--
+    }
--
+}
 impl ::std::fmt::Display for GuardrailContentFilterType {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             GuardrailContentFilterType::Hate => write!(f, "HATE"),
             GuardrailContentFilterType::Insults => write!(f, "INSULTS"),
             GuardrailContentFilterType::Misconduct => write!(f, "MISCONDUCT"),
             GuardrailContentFilterType::PromptAttack => write!(f, "PROMPT_ATTACK"),
             GuardrailContentFilterType::Sexual => write!(f, "SEXUAL"),
             GuardrailContentFilterType::Violence => write!(f, "VIOLENCE"),
             GuardrailContentFilterType::Unknown(value) => write!(f, "{}", value),
--
+        }
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_content_policy_action.rs

@@ -1,0 +108,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// When writing a match expression against `GuardrailContentPolicyAction`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let guardrailcontentpolicyaction = unimplemented!();
 /// match guardrailcontentpolicyaction {
 ///     GuardrailContentPolicyAction::Blocked => { /* ... */ },
 ///     GuardrailContentPolicyAction::None => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `guardrailcontentpolicyaction` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `GuardrailContentPolicyAction::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `GuardrailContentPolicyAction::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `GuardrailContentPolicyAction::NewFeature` is defined.
 /// Specifically, when `guardrailcontentpolicyaction` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `GuardrailContentPolicyAction::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum GuardrailContentPolicyAction {
     #[allow(missing_docs)] // documentation missing in model
     Blocked,
     #[allow(missing_docs)] // documentation missing in model
     None,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
--
+}
 impl ::std::convert::From<&str> for GuardrailContentPolicyAction {
     fn from(s: &str) -> Self {
         match s {
             "BLOCKED" => GuardrailContentPolicyAction::Blocked,
             "NONE" => GuardrailContentPolicyAction::None,
             other => GuardrailContentPolicyAction::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
--
+        }
--
+    }
--
+}
 impl ::std::str::FromStr for GuardrailContentPolicyAction {
     type Err = ::std::convert::Infallible;
--
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(GuardrailContentPolicyAction::from(s))
--
+    }
--
+}
 impl GuardrailContentPolicyAction {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             GuardrailContentPolicyAction::Blocked => "BLOCKED",
             GuardrailContentPolicyAction::None => "NONE",
             GuardrailContentPolicyAction::Unknown(value) => value.as_str(),
--
+        }
--
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["BLOCKED", "NONE"]
--
+    }
--
+}
 impl ::std::convert::AsRef<str> for GuardrailContentPolicyAction {
     fn as_ref(&self) -> &str {
         self.as_str()
--
+    }
--
+}
 impl GuardrailContentPolicyAction {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
--
+        }
--
+    }
--
+}
 impl ::std::fmt::Display for GuardrailContentPolicyAction {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             GuardrailContentPolicyAction::Blocked => write!(f, "BLOCKED"),
             GuardrailContentPolicyAction::None => write!(f, "NONE"),
             GuardrailContentPolicyAction::Unknown(value) => write!(f, "{}", value),
--
+        }
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_content_policy_assessment.rs

@@ -1,0 +64,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// <p>An assessment of a content policy for a guardrail.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GuardrailContentPolicyAssessment {
     /// <p>The content policy filters.</p>
     pub filters: ::std::vec::Vec<crate::types::GuardrailContentFilter>,
--
+}
 impl GuardrailContentPolicyAssessment {
     /// <p>The content policy filters.</p>
     pub fn filters(&self) -> &[crate::types::GuardrailContentFilter] {
         use std::ops::Deref;
         self.filters.deref()
--
+    }
--
+}
 impl GuardrailContentPolicyAssessment {
     /// Creates a new builder-style object to manufacture [`GuardrailContentPolicyAssessment`](crate::types::GuardrailContentPolicyAssessment).
     pub fn builder() -> crate::types::builders::GuardrailContentPolicyAssessmentBuilder {
         crate::types::builders::GuardrailContentPolicyAssessmentBuilder::default()
--
+    }
--
+}
--
 /// A builder for [`GuardrailContentPolicyAssessment`](crate::types::GuardrailContentPolicyAssessment).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GuardrailContentPolicyAssessmentBuilder {
     pub(crate) filters: ::std::option::Option<::std::vec::Vec<crate::types::GuardrailContentFilter>>,
--
+}
 impl GuardrailContentPolicyAssessmentBuilder {
     /// Appends an item to `filters`.
     ///
     /// To override the contents of this collection use [`set_filters`](Self::set_filters).
     ///
     /// <p>The content policy filters.</p>
     pub fn filters(mut self, input: crate::types::GuardrailContentFilter) -> Self {
         let mut v = self.filters.unwrap_or_default();
         v.push(input);
         self.filters = ::std::option::Option::Some(v);
         self
--
+    }
     /// <p>The content policy filters.</p>
     pub fn set_filters(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::GuardrailContentFilter>>) -> Self {
         self.filters = input;
         self
--
+    }
     /// <p>The content policy filters.</p>
     pub fn get_filters(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::GuardrailContentFilter>> {
         &self.filters
--
+    }
     /// Consumes the builder and constructs a [`GuardrailContentPolicyAssessment`](crate::types::GuardrailContentPolicyAssessment).
     /// This method will fail if any of the following fields are not set:
     /// - [`filters`](crate::types::builders::GuardrailContentPolicyAssessmentBuilder::filters)
     pub fn build(self) -> ::std::result::Result<crate::types::GuardrailContentPolicyAssessment, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::types::GuardrailContentPolicyAssessment {
             filters: self.filters.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "filters",
                     "filters was not specified but it is required when building GuardrailContentPolicyAssessment",
--
+                )
             })?,
         })
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_content_qualifier.rs

@@ -1,0 +114,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// When writing a match expression against `GuardrailContentQualifier`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let guardrailcontentqualifier = unimplemented!();
 /// match guardrailcontentqualifier {
 ///     GuardrailContentQualifier::GroundingSource => { /* ... */ },
 ///     GuardrailContentQualifier::GuardContent => { /* ... */ },
 ///     GuardrailContentQualifier::Query => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `guardrailcontentqualifier` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `GuardrailContentQualifier::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `GuardrailContentQualifier::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `GuardrailContentQualifier::NewFeature` is defined.
 /// Specifically, when `guardrailcontentqualifier` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `GuardrailContentQualifier::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum GuardrailContentQualifier {
     #[allow(missing_docs)] // documentation missing in model
     GroundingSource,
     #[allow(missing_docs)] // documentation missing in model
     GuardContent,
     #[allow(missing_docs)] // documentation missing in model
     Query,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
--
+}
 impl ::std::convert::From<&str> for GuardrailContentQualifier {
     fn from(s: &str) -> Self {
         match s {
             "grounding_source" => GuardrailContentQualifier::GroundingSource,
             "guard_content" => GuardrailContentQualifier::GuardContent,
             "query" => GuardrailContentQualifier::Query,
             other => GuardrailContentQualifier::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
--
+        }
--
+    }
--
+}
 impl ::std::str::FromStr for GuardrailContentQualifier {
     type Err = ::std::convert::Infallible;
--
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(GuardrailContentQualifier::from(s))
--
+    }
--
+}
 impl GuardrailContentQualifier {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             GuardrailContentQualifier::GroundingSource => "grounding_source",
             GuardrailContentQualifier::GuardContent => "guard_content",
             GuardrailContentQualifier::Query => "query",
             GuardrailContentQualifier::Unknown(value) => value.as_str(),
--
+        }
--
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["grounding_source", "guard_content", "query"]
--
+    }
--
+}
 impl ::std::convert::AsRef<str> for GuardrailContentQualifier {
     fn as_ref(&self) -> &str {
         self.as_str()
--
+    }
--
+}
 impl GuardrailContentQualifier {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
--
+        }
--
+    }
--
+}
 impl ::std::fmt::Display for GuardrailContentQualifier {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             GuardrailContentQualifier::GroundingSource => write!(f, "grounding_source"),
             GuardrailContentQualifier::GuardContent => write!(f, "guard_content"),
             GuardrailContentQualifier::Query => write!(f, "query"),
             GuardrailContentQualifier::Unknown(value) => write!(f, "{}", value),
--
+        }
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_content_source.rs

@@ -1,0 +108,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// When writing a match expression against `GuardrailContentSource`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let guardrailcontentsource = unimplemented!();
 /// match guardrailcontentsource {
 ///     GuardrailContentSource::Input => { /* ... */ },
 ///     GuardrailContentSource::Output => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `guardrailcontentsource` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `GuardrailContentSource::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `GuardrailContentSource::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `GuardrailContentSource::NewFeature` is defined.
 /// Specifically, when `guardrailcontentsource` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `GuardrailContentSource::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum GuardrailContentSource {
     #[allow(missing_docs)] // documentation missing in model
     Input,
     #[allow(missing_docs)] // documentation missing in model
     Output,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
--
+}
 impl ::std::convert::From<&str> for GuardrailContentSource {
     fn from(s: &str) -> Self {
         match s {
             "INPUT" => GuardrailContentSource::Input,
             "OUTPUT" => GuardrailContentSource::Output,
             other => GuardrailContentSource::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
--
+        }
--
+    }
--
+}
 impl ::std::str::FromStr for GuardrailContentSource {
     type Err = ::std::convert::Infallible;
--
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(GuardrailContentSource::from(s))
--
+    }
--
+}
 impl GuardrailContentSource {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             GuardrailContentSource::Input => "INPUT",
             GuardrailContentSource::Output => "OUTPUT",
             GuardrailContentSource::Unknown(value) => value.as_str(),
--
+        }
--
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["INPUT", "OUTPUT"]
--
+    }
--
+}
 impl ::std::convert::AsRef<str> for GuardrailContentSource {
     fn as_ref(&self) -> &str {
         self.as_str()
--
+    }
--
+}
 impl GuardrailContentSource {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
--
+        }
--
+    }
--
+}
 impl ::std::fmt::Display for GuardrailContentSource {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             GuardrailContentSource::Input => write!(f, "INPUT"),
             GuardrailContentSource::Output => write!(f, "OUTPUT"),
             GuardrailContentSource::Unknown(value) => write!(f, "{}", value),
--
+        }
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_contextual_grounding_filter.rs

@@ -1,0 +167,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// <p>The details for the guardrails contextual grounding filter.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GuardrailContextualGroundingFilter {
     /// <p>The contextual grounding filter type.</p>
     pub r#type: crate::types::GuardrailContextualGroundingFilterType,
     /// <p>The threshold used by contextual grounding filter to determine whether the content is grounded or not.</p>
     pub threshold: f64,
     /// <p>The score generated by contextual grounding filter.</p>
     pub score: f64,
     /// <p>The action performed by the guardrails contextual grounding filter.</p>
     pub action: crate::types::GuardrailContextualGroundingPolicyAction,
     /// <p>Indicates whether content that fails the contextual grounding evaluation (grounding or relevance score less than the corresponding threshold) was detected.</p>
     pub detected: ::std::option::Option<bool>,
--
+}
 impl GuardrailContextualGroundingFilter {
     /// <p>The contextual grounding filter type.</p>
     pub fn r#type(&self) -> &crate::types::GuardrailContextualGroundingFilterType {
         &self.r#type
--
+    }
     /// <p>The threshold used by contextual grounding filter to determine whether the content is grounded or not.</p>
     pub fn threshold(&self) -> f64 {
         self.threshold
--
+    }
     /// <p>The score generated by contextual grounding filter.</p>
     pub fn score(&self) -> f64 {
         self.score
--
+    }
     /// <p>The action performed by the guardrails contextual grounding filter.</p>
     pub fn action(&self) -> &crate::types::GuardrailContextualGroundingPolicyAction {
         &self.action
--
+    }
     /// <p>Indicates whether content that fails the contextual grounding evaluation (grounding or relevance score less than the corresponding threshold) was detected.</p>
     pub fn detected(&self) -> ::std::option::Option<bool> {
         self.detected
--
+    }
--
+}
 impl GuardrailContextualGroundingFilter {
     /// Creates a new builder-style object to manufacture [`GuardrailContextualGroundingFilter`](crate::types::GuardrailContextualGroundingFilter).
     pub fn builder() -> crate::types::builders::GuardrailContextualGroundingFilterBuilder {
         crate::types::builders::GuardrailContextualGroundingFilterBuilder::default()
--
+    }
--
+}
--
 /// A builder for [`GuardrailContextualGroundingFilter`](crate::types::GuardrailContextualGroundingFilter).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GuardrailContextualGroundingFilterBuilder {
     pub(crate) r#type: ::std::option::Option<crate::types::GuardrailContextualGroundingFilterType>,
     pub(crate) threshold: ::std::option::Option<f64>,
     pub(crate) score: ::std::option::Option<f64>,
     pub(crate) action: ::std::option::Option<crate::types::GuardrailContextualGroundingPolicyAction>,
     pub(crate) detected: ::std::option::Option<bool>,
--
+}
 impl GuardrailContextualGroundingFilterBuilder {
     /// <p>The contextual grounding filter type.</p>
     /// This field is required.
     pub fn r#type(mut self, input: crate::types::GuardrailContextualGroundingFilterType) -> Self {
         self.r#type = ::std::option::Option::Some(input);
         self
--
+    }
     /// <p>The contextual grounding filter type.</p>
     pub fn set_type(mut self, input: ::std::option::Option<crate::types::GuardrailContextualGroundingFilterType>) -> Self {
         self.r#type = input;
         self
--
+    }
     /// <p>The contextual grounding filter type.</p>
     pub fn get_type(&self) -> &::std::option::Option<crate::types::GuardrailContextualGroundingFilterType> {
         &self.r#type
--
+    }
     /// <p>The threshold used by contextual grounding filter to determine whether the content is grounded or not.</p>
     /// This field is required.
     pub fn threshold(mut self, input: f64) -> Self {
         self.threshold = ::std::option::Option::Some(input);
         self
--
+    }
     /// <p>The threshold used by contextual grounding filter to determine whether the content is grounded or not.</p>
     pub fn set_threshold(mut self, input: ::std::option::Option<f64>) -> Self {
         self.threshold = input;
         self
--
+    }
     /// <p>The threshold used by contextual grounding filter to determine whether the content is grounded or not.</p>
     pub fn get_threshold(&self) -> &::std::option::Option<f64> {
         &self.threshold
--
+    }
     /// <p>The score generated by contextual grounding filter.</p>
     /// This field is required.
     pub fn score(mut self, input: f64) -> Self {
         self.score = ::std::option::Option::Some(input);
         self
--
+    }
     /// <p>The score generated by contextual grounding filter.</p>
     pub fn set_score(mut self, input: ::std::option::Option<f64>) -> Self {
         self.score = input;
         self
--
+    }
     /// <p>The score generated by contextual grounding filter.</p>
     pub fn get_score(&self) -> &::std::option::Option<f64> {
         &self.score
--
+    }
     /// <p>The action performed by the guardrails contextual grounding filter.</p>
     /// This field is required.
     pub fn action(mut self, input: crate::types::GuardrailContextualGroundingPolicyAction) -> Self {
         self.action = ::std::option::Option::Some(input);
         self
--
+    }
     /// <p>The action performed by the guardrails contextual grounding filter.</p>
     pub fn set_action(mut self, input: ::std::option::Option<crate::types::GuardrailContextualGroundingPolicyAction>) -> Self {
         self.action = input;
         self
--
+    }
     /// <p>The action performed by the guardrails contextual grounding filter.</p>
     pub fn get_action(&self) -> &::std::option::Option<crate::types::GuardrailContextualGroundingPolicyAction> {
         &self.action
--
+    }
     /// <p>Indicates whether content that fails the contextual grounding evaluation (grounding or relevance score less than the corresponding threshold) was detected.</p>
     pub fn detected(mut self, input: bool) -> Self {
         self.detected = ::std::option::Option::Some(input);
         self
--
+    }
     /// <p>Indicates whether content that fails the contextual grounding evaluation (grounding or relevance score less than the corresponding threshold) was detected.</p>
     pub fn set_detected(mut self, input: ::std::option::Option<bool>) -> Self {
         self.detected = input;
         self
--
+    }
     /// <p>Indicates whether content that fails the contextual grounding evaluation (grounding or relevance score less than the corresponding threshold) was detected.</p>
     pub fn get_detected(&self) -> &::std::option::Option<bool> {
         &self.detected
--
+    }
     /// Consumes the builder and constructs a [`GuardrailContextualGroundingFilter`](crate::types::GuardrailContextualGroundingFilter).
     /// This method will fail if any of the following fields are not set:
     /// - [`r#type`](crate::types::builders::GuardrailContextualGroundingFilterBuilder::type)
     /// - [`threshold`](crate::types::builders::GuardrailContextualGroundingFilterBuilder::threshold)
     /// - [`score`](crate::types::builders::GuardrailContextualGroundingFilterBuilder::score)
     /// - [`action`](crate::types::builders::GuardrailContextualGroundingFilterBuilder::action)
     pub fn build(self) -> ::std::result::Result<crate::types::GuardrailContextualGroundingFilter, ::aws_smithy_types::error::operation::BuildError> {
         ::std::result::Result::Ok(crate::types::GuardrailContextualGroundingFilter {
             r#type: self.r#type.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "r#type",
                     "r#type was not specified but it is required when building GuardrailContextualGroundingFilter",
--
+                )
             })?,
             threshold: self.threshold.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "threshold",
                     "threshold was not specified but it is required when building GuardrailContextualGroundingFilter",
--
+                )
             })?,
             score: self.score.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "score",
                     "score was not specified but it is required when building GuardrailContextualGroundingFilter",
--
+                )
             })?,
             action: self.action.ok_or_else(|| {
                 ::aws_smithy_types::error::operation::BuildError::missing_field(
                     "action",
                     "action was not specified but it is required when building GuardrailContextualGroundingFilter",
--
+                )
             })?,
             detected: self.detected,
         })
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_contextual_grounding_filter_type.rs

@@ -1,0 +108,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// When writing a match expression against `GuardrailContextualGroundingFilterType`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let guardrailcontextualgroundingfiltertype = unimplemented!();
 /// match guardrailcontextualgroundingfiltertype {
 ///     GuardrailContextualGroundingFilterType::Grounding => { /* ... */ },
 ///     GuardrailContextualGroundingFilterType::Relevance => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `guardrailcontextualgroundingfiltertype` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `GuardrailContextualGroundingFilterType::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `GuardrailContextualGroundingFilterType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `GuardrailContextualGroundingFilterType::NewFeature` is defined.
 /// Specifically, when `guardrailcontextualgroundingfiltertype` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `GuardrailContextualGroundingFilterType::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum GuardrailContextualGroundingFilterType {
     #[allow(missing_docs)] // documentation missing in model
     Grounding,
     #[allow(missing_docs)] // documentation missing in model
     Relevance,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
--
+}
 impl ::std::convert::From<&str> for GuardrailContextualGroundingFilterType {
     fn from(s: &str) -> Self {
         match s {
             "GROUNDING" => GuardrailContextualGroundingFilterType::Grounding,
             "RELEVANCE" => GuardrailContextualGroundingFilterType::Relevance,
             other => GuardrailContextualGroundingFilterType::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
--
+        }
--
+    }
--
+}
 impl ::std::str::FromStr for GuardrailContextualGroundingFilterType {
     type Err = ::std::convert::Infallible;
--
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(GuardrailContextualGroundingFilterType::from(s))
--
+    }
--
+}
 impl GuardrailContextualGroundingFilterType {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             GuardrailContextualGroundingFilterType::Grounding => "GROUNDING",
             GuardrailContextualGroundingFilterType::Relevance => "RELEVANCE",
             GuardrailContextualGroundingFilterType::Unknown(value) => value.as_str(),
--
+        }
--
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["GROUNDING", "RELEVANCE"]
--
+    }
--
+}
 impl ::std::convert::AsRef<str> for GuardrailContextualGroundingFilterType {
     fn as_ref(&self) -> &str {
         self.as_str()
--
+    }
--
+}
 impl GuardrailContextualGroundingFilterType {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
--
+        }
--
+    }
--
+}
 impl ::std::fmt::Display for GuardrailContextualGroundingFilterType {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             GuardrailContextualGroundingFilterType::Grounding => write!(f, "GROUNDING"),
             GuardrailContextualGroundingFilterType::Relevance => write!(f, "RELEVANCE"),
             GuardrailContextualGroundingFilterType::Unknown(value) => write!(f, "{}", value),
--
+        }
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_contextual_grounding_policy_action.rs

@@ -1,0 +108,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// When writing a match expression against `GuardrailContextualGroundingPolicyAction`, it is important to ensure
 /// your code is forward-compatible. That is, if a match arm handles a case for a
 /// feature that is supported by the service but has not been represented as an enum
 /// variant in a current version of SDK, your code should continue to work when you
 /// upgrade SDK to a future version in which the enum does include a variant for that
 /// feature.
 ///
 /// Here is an example of how you can make a match expression forward-compatible:
 ///
 /// ```text
 /// # let guardrailcontextualgroundingpolicyaction = unimplemented!();
 /// match guardrailcontextualgroundingpolicyaction {
 ///     GuardrailContextualGroundingPolicyAction::Blocked => { /* ... */ },
 ///     GuardrailContextualGroundingPolicyAction::None => { /* ... */ },
 ///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
 ///     _ => { /* ... */ },
 /// }
 /// ```
 /// The above code demonstrates that when `guardrailcontextualgroundingpolicyaction` represents
 /// `NewFeature`, the execution path will lead to the second last match arm,
 /// even though the enum does not contain a variant `GuardrailContextualGroundingPolicyAction::NewFeature`
 /// in the current version of SDK. The reason is that the variable `other`,
 /// created by the `@` operator, is bound to
 /// `GuardrailContextualGroundingPolicyAction::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
 /// and calling `as_str` on it yields `"NewFeature"`.
 /// This match expression is forward-compatible when executed with a newer
 /// version of SDK where the variant `GuardrailContextualGroundingPolicyAction::NewFeature` is defined.
 /// Specifically, when `guardrailcontextualgroundingpolicyaction` represents `NewFeature`,
 /// the execution path will hit the second last match arm as before by virtue of
 /// calling `as_str` on `GuardrailContextualGroundingPolicyAction::NewFeature` also yielding `"NewFeature"`.
 ///
 /// Explicitly matching on the `Unknown` variant should
 /// be avoided for two reasons:
 /// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
 /// - It might inadvertently shadow other intended match arms.
 ///
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum GuardrailContextualGroundingPolicyAction {
     #[allow(missing_docs)] // documentation missing in model
     Blocked,
     #[allow(missing_docs)] // documentation missing in model
     None,
     /// `Unknown` contains new variants that have been added since this code was generated.
     #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
     Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
--
+}
 impl ::std::convert::From<&str> for GuardrailContextualGroundingPolicyAction {
     fn from(s: &str) -> Self {
         match s {
             "BLOCKED" => GuardrailContextualGroundingPolicyAction::Blocked,
             "NONE" => GuardrailContextualGroundingPolicyAction::None,
             other => GuardrailContextualGroundingPolicyAction::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
--
+        }
--
+    }
--
+}
 impl ::std::str::FromStr for GuardrailContextualGroundingPolicyAction {
     type Err = ::std::convert::Infallible;
--
     fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
         ::std::result::Result::Ok(GuardrailContextualGroundingPolicyAction::from(s))
--
+    }
--
+}
 impl GuardrailContextualGroundingPolicyAction {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             GuardrailContextualGroundingPolicyAction::Blocked => "BLOCKED",
             GuardrailContextualGroundingPolicyAction::None => "NONE",
             GuardrailContextualGroundingPolicyAction::Unknown(value) => value.as_str(),
--
+        }
--
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["BLOCKED", "NONE"]
--
+    }
--
+}
 impl ::std::convert::AsRef<str> for GuardrailContextualGroundingPolicyAction {
     fn as_ref(&self) -> &str {
         self.as_str()
--
+    }
--
+}
 impl GuardrailContextualGroundingPolicyAction {
     /// Parses the enum value while disallowing unknown variants.
     ///
     /// Unknown variants will result in an error.
     pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
         match Self::from(value) {
             #[allow(deprecated)]
             Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
             known => Ok(known),
--
+        }
--
+    }
--
+}
 impl ::std::fmt::Display for GuardrailContextualGroundingPolicyAction {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         match self {
             GuardrailContextualGroundingPolicyAction::Blocked => write!(f, "BLOCKED"),
             GuardrailContextualGroundingPolicyAction::None => write!(f, "NONE"),
             GuardrailContextualGroundingPolicyAction::Unknown(value) => write!(f, "{}", value),
--
+        }
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_contextual_grounding_policy_assessment.rs

@@ -1,0 +56,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// <p>The policy assessment details for the guardrails contextual grounding filter.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GuardrailContextualGroundingPolicyAssessment {
     /// <p>The filter details for the guardrails contextual grounding filter.</p>
     pub filters: ::std::option::Option<::std::vec::Vec<crate::types::GuardrailContextualGroundingFilter>>,
--
+}
 impl GuardrailContextualGroundingPolicyAssessment {
     /// <p>The filter details for the guardrails contextual grounding filter.</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 `.filters.is_none()`.
     pub fn filters(&self) -> &[crate::types::GuardrailContextualGroundingFilter] {
         self.filters.as_deref().unwrap_or_default()
--
+    }
--
+}
 impl GuardrailContextualGroundingPolicyAssessment {
     /// Creates a new builder-style object to manufacture [`GuardrailContextualGroundingPolicyAssessment`](crate::types::GuardrailContextualGroundingPolicyAssessment).
     pub fn builder() -> crate::types::builders::GuardrailContextualGroundingPolicyAssessmentBuilder {
         crate::types::builders::GuardrailContextualGroundingPolicyAssessmentBuilder::default()
--
+    }
--
+}
--
 /// A builder for [`GuardrailContextualGroundingPolicyAssessment`](crate::types::GuardrailContextualGroundingPolicyAssessment).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GuardrailContextualGroundingPolicyAssessmentBuilder {
     pub(crate) filters: ::std::option::Option<::std::vec::Vec<crate::types::GuardrailContextualGroundingFilter>>,
--
+}
 impl GuardrailContextualGroundingPolicyAssessmentBuilder {
     /// Appends an item to `filters`.
     ///
     /// To override the contents of this collection use [`set_filters`](Self::set_filters).
     ///
     /// <p>The filter details for the guardrails contextual grounding filter.</p>
     pub fn filters(mut self, input: crate::types::GuardrailContextualGroundingFilter) -> Self {
         let mut v = self.filters.unwrap_or_default();
         v.push(input);
         self.filters = ::std::option::Option::Some(v);
         self
--
+    }
     /// <p>The filter details for the guardrails contextual grounding filter.</p>
     pub fn set_filters(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::GuardrailContextualGroundingFilter>>) -> Self {
         self.filters = input;
         self
--
+    }
     /// <p>The filter details for the guardrails contextual grounding filter.</p>
     pub fn get_filters(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::GuardrailContextualGroundingFilter>> {
         &self.filters
--
+    }
     /// Consumes the builder and constructs a [`GuardrailContextualGroundingPolicyAssessment`](crate::types::GuardrailContextualGroundingPolicyAssessment).
     pub fn build(self) -> crate::types::GuardrailContextualGroundingPolicyAssessment {
         crate::types::GuardrailContextualGroundingPolicyAssessment { filters: self.filters }
--
+    }
--
+}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/types/_guardrail_converse_content_block.rs

@@ -1,0 +62,0 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// <p></p>
 /// <p>A content block for selective guarding with the <a href="https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html">Converse</a> or <a href="https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html">ConverseStream</a> API operations.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq)]
 pub enum GuardrailConverseContentBlock {
     /// <p>Image within converse content block to be evaluated by the guardrail.</p>
     Image(crate::types::GuardrailConverseImageBlock),
     /// <p>The text to guard.</p>
     Text(crate::types::GuardrailConverseTextBlock),
     /// The `Unknown` variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version.
     /// An unknown enum variant
     ///
     /// _Note: If you encounter this error, consider upgrading your SDK to the latest version._
     /// The `Unknown` variant represents cases where the server sent a value that wasn't recognized
     /// by the client. This can happen when the server adds new functionality, but the client has not been updated.
     /// To investigate this, consider turning on debug logging to print the raw HTTP response.
     #[non_exhaustive]
     Unknown,
--
+}
 impl GuardrailConverseContentBlock {
     /// Tries to convert the enum instance into [`Image`](crate::types::GuardrailConverseContentBlock::Image), extracting the inner [`GuardrailConverseImageBlock`](crate::types::GuardrailConverseImageBlock).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_image(&self) -> ::std::result::Result<&crate::types::GuardrailConverseImageBlock, &Self> {
         if let GuardrailConverseContentBlock::Image(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
--
+        }
--
+    }
     /// Returns true if this is a [`Image`](crate::types::GuardrailConverseContentBlock::Image).
     pub fn is_image(&self) -> bool {
         self.as_image().is_ok()
--
+    }
     /// Tries to convert the enum instance into [`Text`](crate::types::GuardrailConverseContentBlock::Text), extracting the inner [`GuardrailConverseTextBlock`](crate::types::GuardrailConverseTextBlock).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_text(&self) -> ::std::result::Result<&crate::types::GuardrailConverseTextBlock, &Self> {
         if let GuardrailConverseContentBlock::Text(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
--
+        }
--
+    }
     /// Returns true if this is a [`Text`](crate::types::GuardrailConverseContentBlock::Text).
     pub fn is_text(&self) -> bool {
         self.as_text().is_ok()
--
+    }
     /// Returns true if the enum instance is the `Unknown` variant.
     pub fn is_unknown(&self) -> bool {
         matches!(self, Self::Unknown)
--
+    }
--
+}
 impl ::std::fmt::Debug for GuardrailConverseContentBlock {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match self {
             GuardrailConverseContentBlock::Image(_) => f.debug_tuple("*** Sensitive Data Redacted ***").finish(),
             GuardrailConverseContentBlock::Text(val) => f.debug_tuple("Text").field(&val).finish(),
             GuardrailConverseContentBlock::Unknown => f.debug_tuple("Unknown").finish(),
--
+        }
--
+    }
--
+}

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