AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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

@@ -4,4 +129,140 @@
   24     24   
    "com.amazonaws.bedrockruntime",
   25     25   
    "GuardrailCoverage",
   26     26   
);
   27     27   
static GUARDRAILCOVERAGE_MEMBER_TEXT_CHARACTERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.bedrockruntime#GuardrailCoverage$textCharacters",
   30     30   
        "com.amazonaws.bedrockruntime",
   31     31   
        "GuardrailCoverage",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::Structure,
   34         -
    "text_characters",
          34  +
    "textCharacters",
   35     35   
    0,
   36     36   
);
   37     37   
static GUARDRAILCOVERAGE_MEMBER_IMAGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.bedrockruntime#GuardrailCoverage$images",
   40     40   
        "com.amazonaws.bedrockruntime",
   41     41   
        "GuardrailCoverage",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::Structure,
   44     44   
    "images",
   45     45   
    1,
   46     46   
);
   47     47   
static GUARDRAILCOVERAGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    GUARDRAILCOVERAGE_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[&GUARDRAILCOVERAGE_MEMBER_TEXT_CHARACTERS, &GUARDRAILCOVERAGE_MEMBER_IMAGES],
   51     51   
);
   52     52   
impl GuardrailCoverage {
   53     53   
    /// The schema for this shape.
   54     54   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILCOVERAGE_SCHEMA;
   55     55   
}
   56     56   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailCoverage {
   57     57   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   58     58   
    fn serialize_members(
   59     59   
        &self,
   60     60   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   61     61   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   62     62   
        if let Some(ref val) = self.text_characters {
   63     63   
            ser.write_struct(&GUARDRAILCOVERAGE_MEMBER_TEXT_CHARACTERS, val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.images {
   66     66   
            ser.write_struct(&GUARDRAILCOVERAGE_MEMBER_IMAGES, val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl GuardrailCoverage {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&GUARDRAILCOVERAGE_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&GUARDRAILCOVERAGE_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.text_characters = Some(crate::types::GuardrailTextCharactersCoverage::deserialize(deser)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.images = Some(crate::types::GuardrailImageCoverage::deserialize(deser)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
   97     97   
        Ok(builder.build())
   98     98   
    }
   99     99   
}
         100  +
impl GuardrailCoverage {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  100    111   
impl GuardrailCoverage {
  101    112   
    /// Creates a new builder-style object to manufacture [`GuardrailCoverage`](crate::types::GuardrailCoverage).
  102    113   
    pub fn builder() -> crate::types::builders::GuardrailCoverageBuilder {
  103    114   
        crate::types::builders::GuardrailCoverageBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`GuardrailCoverage`](crate::types::GuardrailCoverage).
  108    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  109    120   
#[non_exhaustive]

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

@@ -11,11 +160,172 @@
   31     31   
    "com.amazonaws.bedrockruntime",
   32     32   
    "GuardrailCustomWord",
   33     33   
);
   34     34   
static GUARDRAILCUSTOMWORD_MEMBER_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.bedrockruntime#GuardrailCustomWord$match",
   37     37   
        "com.amazonaws.bedrockruntime",
   38     38   
        "GuardrailCustomWord",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "r##match",
          41  +
    "match",
   42     42   
    0,
   43     43   
);
   44     44   
static GUARDRAILCUSTOMWORD_MEMBER_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.bedrockruntime#GuardrailCustomWord$action",
   47     47   
        "com.amazonaws.bedrockruntime",
   48     48   
        "GuardrailCustomWord",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51     51   
    "action",
   52     52   
    1,
   53     53   
);
   54     54   
static GUARDRAILCUSTOMWORD_MEMBER_DETECTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.bedrockruntime#GuardrailCustomWord$detected",
   57     57   
        "com.amazonaws.bedrockruntime",
   58     58   
        "GuardrailCustomWord",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::Boolean,
   61     61   
    "detected",
   62     62   
    2,
   63     63   
);
   64     64   
static GUARDRAILCUSTOMWORD_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    GUARDRAILCUSTOMWORD_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &GUARDRAILCUSTOMWORD_MEMBER_MATCH,
   69     69   
        &GUARDRAILCUSTOMWORD_MEMBER_ACTION,
   70     70   
        &GUARDRAILCUSTOMWORD_MEMBER_DETECTED,
   71     71   
    ],
   72     72   
);
   73     73   
impl GuardrailCustomWord {
   74     74   
    /// The schema for this shape.
   75     75   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILCUSTOMWORD_SCHEMA;
   76     76   
}
   77     77   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailCustomWord {
   78     78   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   79     79   
    fn serialize_members(
   80     80   
        &self,
   81     81   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   82     82   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   83     83   
        {
   84     84   
            let val = &self.r#match;
   85     85   
            ser.write_string(&GUARDRAILCUSTOMWORD_MEMBER_MATCH, val)?;
   86     86   
        }
   87     87   
        {
   88     88   
            let val = &self.action;
   89     89   
            ser.write_string(&GUARDRAILCUSTOMWORD_MEMBER_ACTION, val.as_str())?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.detected {
   92     92   
            ser.write_boolean(&GUARDRAILCUSTOMWORD_MEMBER_DETECTED, *val)?;
   93     93   
        }
   94     94   
        Ok(())
   95     95   
    }
   96     96   
}
   97     97   
impl GuardrailCustomWord {
   98     98   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   99         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  100         -
        deserializer: &mut D,
          99  +
    pub fn deserialize(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  101    101   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        #[allow(unused_variables, unused_mut)]
  103    103   
        let mut builder = Self::builder();
  104    104   
        #[allow(
  105    105   
            unused_variables,
  106    106   
            unreachable_code,
  107    107   
            clippy::single_match,
  108    108   
            clippy::match_single_binding,
  109    109   
            clippy::diverging_sub_expression
  110    110   
        )]
  111         -
        deserializer.read_struct(&GUARDRAILCUSTOMWORD_SCHEMA, (), |_, member, deser| {
         111  +
        deserializer.read_struct(&GUARDRAILCUSTOMWORD_SCHEMA, &mut |member, deser| {
  112    112   
            match member.member_index() {
  113    113   
                Some(0) => {
  114    114   
                    builder.r#match = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                Some(1) => {
  117    117   
                    builder.action = Some(crate::types::GuardrailWordPolicyAction::from(deser.read_string(member)?.as_str()));
  118    118   
                }
  119    119   
                Some(2) => {
  120    120   
                    builder.detected = Some(deser.read_boolean(member)?);
  121    121   
                }
  122    122   
                _ => {}
  123    123   
            }
  124    124   
            Ok(())
  125    125   
        })?;
         126  +
        builder.r#match = builder.r#match.or(Some(String::new()));
  126    127   
        builder
  127    128   
            .build()
  128    129   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  129    130   
    }
  130    131   
}
         132  +
impl GuardrailCustomWord {
         133  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         134  +
    pub fn deserialize_with_response(
         135  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         136  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         137  +
        _status: u16,
         138  +
        _body: &[u8],
         139  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         140  +
        Self::deserialize(deserializer)
         141  +
    }
         142  +
}
  131    143   
impl GuardrailCustomWord {
  132    144   
    /// Creates a new builder-style object to manufacture [`GuardrailCustomWord`](crate::types::GuardrailCustomWord).
  133    145   
    pub fn builder() -> crate::types::builders::GuardrailCustomWordBuilder {
  134    146   
        crate::types::builders::GuardrailCustomWordBuilder::default()
  135    147   
    }
  136    148   
}
  137    149   
  138    150   
/// A builder for [`GuardrailCustomWord`](crate::types::GuardrailCustomWord).
  139    151   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  140    152   
#[non_exhaustive]

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

@@ -46,46 +144,152 @@
   66     66   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   67     67   
    fn serialize_members(
   68     68   
        &self,
   69     69   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   70     70   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   71     71   
        {
   72     72   
            let val = &self.format;
   73     73   
            ser.write_string(&GUARDRAILIMAGEBLOCK_MEMBER_FORMAT, val.as_str())?;
   74     74   
        }
   75     75   
        if let Some(ref val) = self.source {
   76         -
            ser.write_null(&GUARDRAILIMAGEBLOCK_MEMBER_SOURCE)?;
          76  +
            ser.write_struct(&GUARDRAILIMAGEBLOCK_MEMBER_SOURCE, val)?;
   77     77   
        }
   78     78   
        Ok(())
   79     79   
    }
   80     80   
}
   81     81   
impl GuardrailImageBlock {
   82     82   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   83         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   84         -
        deserializer: &mut D,
          83  +
    pub fn deserialize(
          84  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   85     85   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   86     86   
        #[allow(unused_variables, unused_mut)]
   87     87   
        let mut builder = Self::builder();
   88     88   
        #[allow(
   89     89   
            unused_variables,
   90     90   
            unreachable_code,
   91     91   
            clippy::single_match,
   92     92   
            clippy::match_single_binding,
   93     93   
            clippy::diverging_sub_expression
   94     94   
        )]
   95         -
        deserializer.read_struct(&GUARDRAILIMAGEBLOCK_SCHEMA, (), |_, member, deser| {
          95  +
        deserializer.read_struct(&GUARDRAILIMAGEBLOCK_SCHEMA, &mut |member, deser| {
   96     96   
            match member.member_index() {
   97     97   
                Some(0) => {
   98     98   
                    builder.format = Some(crate::types::GuardrailImageFormat::from(deser.read_string(member)?.as_str()));
   99     99   
                }
  100    100   
                Some(1) => {
  101         -
                    builder.source = Some({
  102         -
                        let _ = member;
  103         -
                        todo!("deserialize aggregate")
  104         -
                    });
         101  +
                    builder.source = Some(crate::types::GuardrailImageSource::deserialize(deser)?);
  105    102   
                }
  106    103   
                _ => {}
  107    104   
            }
  108    105   
            Ok(())
  109    106   
        })?;
  110    107   
        builder
  111    108   
            .build()
  112    109   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  113    110   
    }
  114    111   
}
         112  +
impl GuardrailImageBlock {
         113  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         114  +
    pub fn deserialize_with_response(
         115  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         116  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         117  +
        _status: u16,
         118  +
        _body: &[u8],
         119  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         120  +
        Self::deserialize(deserializer)
         121  +
    }
         122  +
}
  115    123   
impl GuardrailImageBlock {
  116    124   
    /// Creates a new builder-style object to manufacture [`GuardrailImageBlock`](crate::types::GuardrailImageBlock).
  117    125   
    pub fn builder() -> crate::types::builders::GuardrailImageBlockBuilder {
  118    126   
        crate::types::builders::GuardrailImageBlockBuilder::default()
  119    127   
    }
  120    128   
}
  121    129   
  122    130   
/// A builder for [`GuardrailImageBlock`](crate::types::GuardrailImageBlock).
  123    131   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  124    132   
#[non_exhaustive]

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

@@ -43,43 +129,140 @@
   63     63   
            ser.write_integer(&GUARDRAILIMAGECOVERAGE_MEMBER_GUARDED, *val)?;
   64     64   
        }
   65     65   
        if let Some(ref val) = self.total {
   66     66   
            ser.write_integer(&GUARDRAILIMAGECOVERAGE_MEMBER_TOTAL, *val)?;
   67     67   
        }
   68     68   
        Ok(())
   69     69   
    }
   70     70   
}
   71     71   
impl GuardrailImageCoverage {
   72     72   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   73         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   74         -
        deserializer: &mut D,
          73  +
    pub fn deserialize(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   75     75   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   76     76   
        #[allow(unused_variables, unused_mut)]
   77     77   
        let mut builder = Self::builder();
   78     78   
        #[allow(
   79     79   
            unused_variables,
   80     80   
            unreachable_code,
   81     81   
            clippy::single_match,
   82     82   
            clippy::match_single_binding,
   83     83   
            clippy::diverging_sub_expression
   84     84   
        )]
   85         -
        deserializer.read_struct(&GUARDRAILIMAGECOVERAGE_SCHEMA, (), |_, member, deser| {
          85  +
        deserializer.read_struct(&GUARDRAILIMAGECOVERAGE_SCHEMA, &mut |member, deser| {
   86     86   
            match member.member_index() {
   87     87   
                Some(0) => {
   88     88   
                    builder.guarded = Some(deser.read_integer(member)?);
   89     89   
                }
   90     90   
                Some(1) => {
   91     91   
                    builder.total = Some(deser.read_integer(member)?);
   92     92   
                }
   93     93   
                _ => {}
   94     94   
            }
   95     95   
            Ok(())
   96     96   
        })?;
   97     97   
        Ok(builder.build())
   98     98   
    }
   99     99   
}
         100  +
impl GuardrailImageCoverage {
         101  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         102  +
    pub fn deserialize_with_response(
         103  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         104  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         105  +
        _status: u16,
         106  +
        _body: &[u8],
         107  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         108  +
        Self::deserialize(deserializer)
         109  +
    }
         110  +
}
  100    111   
impl GuardrailImageCoverage {
  101    112   
    /// Creates a new builder-style object to manufacture [`GuardrailImageCoverage`](crate::types::GuardrailImageCoverage).
  102    113   
    pub fn builder() -> crate::types::builders::GuardrailImageCoverageBuilder {
  103    114   
        crate::types::builders::GuardrailImageCoverageBuilder::default()
  104    115   
    }
  105    116   
}
  106    117   
  107    118   
/// A builder for [`GuardrailImageCoverage`](crate::types::GuardrailImageCoverage).
  108    119   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  109    120   
#[non_exhaustive]

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

@@ -14,14 +0,100 @@
   34     34   
    /// Returns true if the enum instance is the `Unknown` variant.
   35     35   
    pub fn is_unknown(&self) -> bool {
   36     36   
        matches!(self, Self::Unknown)
   37     37   
    }
   38     38   
}
   39     39   
impl ::std::fmt::Debug for GuardrailImageSource {
   40     40   
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
   41     41   
        ::std::write!(f, "*** Sensitive Data Redacted ***")
   42     42   
    }
   43     43   
}
          44  +
static GUARDRAILIMAGESOURCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          45  +
    "com.amazonaws.bedrockruntime#GuardrailImageSource",
          46  +
    "com.amazonaws.bedrockruntime",
          47  +
    "GuardrailImageSource",
          48  +
);
          49  +
static GUARDRAILIMAGESOURCE_MEMBER_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          50  +
    ::aws_smithy_schema::ShapeId::from_static(
          51  +
        "com.amazonaws.bedrockruntime#GuardrailImageSource$bytes",
          52  +
        "com.amazonaws.bedrockruntime",
          53  +
        "GuardrailImageSource",
          54  +
    ),
          55  +
    ::aws_smithy_schema::ShapeType::Blob,
          56  +
    "bytes",
          57  +
    0,
          58  +
);
          59  +
static GUARDRAILIMAGESOURCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          60  +
    GUARDRAILIMAGESOURCE_SCHEMA_ID,
          61  +
    ::aws_smithy_schema::ShapeType::Union,
          62  +
    &[&GUARDRAILIMAGESOURCE_MEMBER_BYTES],
          63  +
)
          64  +
.with_sensitive();
          65  +
impl GuardrailImageSource {
          66  +
    /// The schema for this shape.
          67  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILIMAGESOURCE_SCHEMA;
          68  +
}
          69  +
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailImageSource {
          70  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          71  +
    fn serialize_members(
          72  +
        &self,
          73  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          74  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          75  +
        match self {
          76  +
            Self::Bytes(val) => {
          77  +
                ser.write_blob(&GUARDRAILIMAGESOURCE_MEMBER_BYTES, val)?;
          78  +
            }
          79  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
          80  +
        }
          81  +
        Ok(())
          82  +
    }
          83  +
}
          84  +
impl GuardrailImageSource {
          85  +
    /// Deserializes this union from a [`ShapeDeserializer`].
          86  +
    pub fn deserialize(
          87  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          88  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          89  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
          90  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
          91  +
        deserializer.read_struct(&GUARDRAILIMAGESOURCE_SCHEMA, &mut |member, deser| {
          92  +
            result = ::std::option::Option::Some(match member.member_index() {
          93  +
                Some(0) => Self::Bytes(deser.read_blob(member)?),
          94  +
                _ => Self::Unknown,
          95  +
            });
          96  +
            Ok(())
          97  +
        })?;
          98  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
          99  +
    }
         100  +
}

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

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.bedrockruntime",
   31     31   
    "GuardrailInvocationMetrics",
   32     32   
);
   33     33   
static GUARDRAILINVOCATIONMETRICS_MEMBER_GUARDRAIL_PROCESSING_LATENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.bedrockruntime#GuardrailInvocationMetrics$guardrailProcessingLatency",
   36     36   
        "com.amazonaws.bedrockruntime",
   37     37   
        "GuardrailInvocationMetrics",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Long,
   40         -
    "guardrail_processing_latency",
          40  +
    "guardrailProcessingLatency",
   41     41   
    0,
   42     42   
);
   43     43   
static GUARDRAILINVOCATIONMETRICS_MEMBER_USAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.bedrockruntime#GuardrailInvocationMetrics$usage",
   46     46   
        "com.amazonaws.bedrockruntime",
   47     47   
        "GuardrailInvocationMetrics",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    "usage",
   51     51   
    1,
   52     52   
);
   53     53   
static GUARDRAILINVOCATIONMETRICS_MEMBER_GUARDRAIL_COVERAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.bedrockruntime#GuardrailInvocationMetrics$guardrailCoverage",
   56     56   
        "com.amazonaws.bedrockruntime",
   57     57   
        "GuardrailInvocationMetrics",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Structure,
   60         -
    "guardrail_coverage",
          60  +
    "guardrailCoverage",
   61     61   
    2,
   62     62   
);
   63     63   
static GUARDRAILINVOCATIONMETRICS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    GUARDRAILINVOCATIONMETRICS_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &GUARDRAILINVOCATIONMETRICS_MEMBER_GUARDRAIL_PROCESSING_LATENCY,
   68     68   
        &GUARDRAILINVOCATIONMETRICS_MEMBER_USAGE,
   69     69   
        &GUARDRAILINVOCATIONMETRICS_MEMBER_GUARDRAIL_COVERAGE,
   70     70   
    ],
   71     71   
);
   72     72   
impl GuardrailInvocationMetrics {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILINVOCATIONMETRICS_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailInvocationMetrics {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        if let Some(ref val) = self.guardrail_processing_latency {
   83     83   
            ser.write_long(&GUARDRAILINVOCATIONMETRICS_MEMBER_GUARDRAIL_PROCESSING_LATENCY, *val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.usage {
   86     86   
            ser.write_struct(&GUARDRAILINVOCATIONMETRICS_MEMBER_USAGE, val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.guardrail_coverage {
   89     89   
            ser.write_struct(&GUARDRAILINVOCATIONMETRICS_MEMBER_GUARDRAIL_COVERAGE, val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl GuardrailInvocationMetrics {
   95     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        #[allow(unused_variables, unused_mut)]
  100    100   
        let mut builder = Self::builder();
  101    101   
        #[allow(
  102    102   
            unused_variables,
  103    103   
            unreachable_code,
  104    104   
            clippy::single_match,
  105    105   
            clippy::match_single_binding,
  106    106   
            clippy::diverging_sub_expression
  107    107   
        )]
  108         -
        deserializer.read_struct(&GUARDRAILINVOCATIONMETRICS_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&GUARDRAILINVOCATIONMETRICS_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.guardrail_processing_latency = Some(deser.read_long(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.usage = Some(crate::types::GuardrailUsage::deserialize(deser)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.guardrail_coverage = Some(crate::types::GuardrailCoverage::deserialize(deser)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl GuardrailInvocationMetrics {
         127  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         128  +
    pub fn deserialize_with_response(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         130  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         131  +
        _status: u16,
         132  +
        _body: &[u8],
         133  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         134  +
        Self::deserialize(deserializer)
         135  +
    }
         136  +
}
  126    137   
impl GuardrailInvocationMetrics {
  127    138   
    /// Creates a new builder-style object to manufacture [`GuardrailInvocationMetrics`](crate::types::GuardrailInvocationMetrics).
  128    139   
    pub fn builder() -> crate::types::builders::GuardrailInvocationMetricsBuilder {
  129    140   
        crate::types::builders::GuardrailInvocationMetricsBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`GuardrailInvocationMetrics`](crate::types::GuardrailInvocationMetrics).
  134    145   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  135    146   
#[non_exhaustive]

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

@@ -17,17 +87,87 @@
   37     37   
    "com.amazonaws.bedrockruntime",
   38     38   
    "GuardrailManagedWord",
   39     39   
);
   40     40   
static GUARDRAILMANAGEDWORD_MEMBER_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.bedrockruntime#GuardrailManagedWord$match",
   43     43   
        "com.amazonaws.bedrockruntime",
   44     44   
        "GuardrailManagedWord",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "r##match",
          47  +
    "match",
   48     48   
    0,
   49     49   
);
   50     50   
static GUARDRAILMANAGEDWORD_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.bedrockruntime#GuardrailManagedWord$type",
   53     53   
        "com.amazonaws.bedrockruntime",
   54     54   
        "GuardrailManagedWord",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "r##type",
          57  +
    "type",
   58     58   
    1,
   59     59   
);
   60     60   
static GUARDRAILMANAGEDWORD_MEMBER_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.bedrockruntime#GuardrailManagedWord$action",
   63     63   
        "com.amazonaws.bedrockruntime",
   64     64   
        "GuardrailManagedWord",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67     67   
    "action",
@@ -90,90 +184,196 @@
  110    110   
            ser.write_string(&GUARDRAILMANAGEDWORD_MEMBER_ACTION, val.as_str())?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.detected {
  113    113   
            ser.write_boolean(&GUARDRAILMANAGEDWORD_MEMBER_DETECTED, *val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl GuardrailManagedWord {
  119    119   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         120  +
    pub fn deserialize(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    122   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        #[allow(unused_variables, unused_mut)]
  124    124   
        let mut builder = Self::builder();
  125    125   
        #[allow(
  126    126   
            unused_variables,
  127    127   
            unreachable_code,
  128    128   
            clippy::single_match,
  129    129   
            clippy::match_single_binding,
  130    130   
            clippy::diverging_sub_expression
  131    131   
        )]
  132         -
        deserializer.read_struct(&GUARDRAILMANAGEDWORD_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&GUARDRAILMANAGEDWORD_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.r#match = Some(deser.read_string(member)?);
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.r#type = Some(crate::types::GuardrailManagedWordType::from(deser.read_string(member)?.as_str()));
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.action = Some(crate::types::GuardrailWordPolicyAction::from(deser.read_string(member)?.as_str()));
  142    142   
                }
  143    143   
                Some(3) => {
  144    144   
                    builder.detected = Some(deser.read_boolean(member)?);
  145    145   
                }
  146    146   
                _ => {}
  147    147   
            }
  148    148   
            Ok(())
  149    149   
        })?;
         150  +
        builder.r#match = builder.r#match.or(Some(String::new()));
  150    151   
        builder
  151    152   
            .build()
  152    153   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  153    154   
    }
  154    155   
}
         156  +
impl GuardrailManagedWord {
         157  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         158  +
    pub fn deserialize_with_response(
         159  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         160  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         161  +
        _status: u16,
         162  +
        _body: &[u8],
         163  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         164  +
        Self::deserialize(deserializer)
         165  +
    }
         166  +
}
  155    167   
impl GuardrailManagedWord {
  156    168   
    /// Creates a new builder-style object to manufacture [`GuardrailManagedWord`](crate::types::GuardrailManagedWord).
  157    169   
    pub fn builder() -> crate::types::builders::GuardrailManagedWordBuilder {
  158    170   
        crate::types::builders::GuardrailManagedWordBuilder::default()
  159    171   
    }
  160    172   
}
  161    173   
  162    174   
/// A builder for [`GuardrailManagedWord`](crate::types::GuardrailManagedWord).
  163    175   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  164    176   
#[non_exhaustive]

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

@@ -24,24 +107,118 @@
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.text {
   47     47   
            ser.write_string(&GUARDRAILOUTPUTCONTENT_MEMBER_TEXT, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl GuardrailOutputContent {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&GUARDRAILOUTPUTCONTENT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&GUARDRAILOUTPUTCONTENT_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.text = Some(deser.read_string(member)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl GuardrailOutputContent {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl GuardrailOutputContent {
   79     90   
    /// Creates a new builder-style object to manufacture [`GuardrailOutputContent`](crate::types::GuardrailOutputContent).
   80     91   
    pub fn builder() -> crate::types::builders::GuardrailOutputContentBuilder {
   81     92   
        crate::types::builders::GuardrailOutputContentBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`GuardrailOutputContent`](crate::types::GuardrailOutputContent).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

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

@@ -17,17 +87,87 @@
   37     37   
    "com.amazonaws.bedrockruntime",
   38     38   
    "GuardrailPiiEntityFilter",
   39     39   
);
   40     40   
static GUARDRAILPIIENTITYFILTER_MEMBER_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.bedrockruntime#GuardrailPiiEntityFilter$match",
   43     43   
        "com.amazonaws.bedrockruntime",
   44     44   
        "GuardrailPiiEntityFilter",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "r##match",
          47  +
    "match",
   48     48   
    0,
   49     49   
);
   50     50   
static GUARDRAILPIIENTITYFILTER_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.bedrockruntime#GuardrailPiiEntityFilter$type",
   53     53   
        "com.amazonaws.bedrockruntime",
   54     54   
        "GuardrailPiiEntityFilter",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "r##type",
          57  +
    "type",
   58     58   
    1,
   59     59   
);
   60     60   
static GUARDRAILPIIENTITYFILTER_MEMBER_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.bedrockruntime#GuardrailPiiEntityFilter$action",
   63     63   
        "com.amazonaws.bedrockruntime",
   64     64   
        "GuardrailPiiEntityFilter",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67     67   
    "action",
@@ -90,90 +186,198 @@
  110    110   
            ser.write_string(&GUARDRAILPIIENTITYFILTER_MEMBER_ACTION, val.as_str())?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.detected {
  113    113   
            ser.write_boolean(&GUARDRAILPIIENTITYFILTER_MEMBER_DETECTED, *val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl GuardrailPiiEntityFilter {
  119    119   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         120  +
    pub fn deserialize(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    122   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        #[allow(unused_variables, unused_mut)]
  124    124   
        let mut builder = Self::builder();
  125    125   
        #[allow(
  126    126   
            unused_variables,
  127    127   
            unreachable_code,
  128    128   
            clippy::single_match,
  129    129   
            clippy::match_single_binding,
  130    130   
            clippy::diverging_sub_expression
  131    131   
        )]
  132         -
        deserializer.read_struct(&GUARDRAILPIIENTITYFILTER_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&GUARDRAILPIIENTITYFILTER_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.r#match = Some(deser.read_string(member)?);
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.r#type = Some(crate::types::GuardrailPiiEntityType::from(deser.read_string(member)?.as_str()));
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.action = Some(crate::types::GuardrailSensitiveInformationPolicyAction::from(
  142    142   
                        deser.read_string(member)?.as_str(),
  143    143   
                    ));
  144    144   
                }
  145    145   
                Some(3) => {
  146    146   
                    builder.detected = Some(deser.read_boolean(member)?);
  147    147   
                }
  148    148   
                _ => {}
  149    149   
            }
  150    150   
            Ok(())
  151    151   
        })?;
         152  +
        builder.r#match = builder.r#match.or(Some(String::new()));
  152    153   
        builder
  153    154   
            .build()
  154    155   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  155    156   
    }
  156    157   
}
         158  +
impl GuardrailPiiEntityFilter {
         159  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         160  +
    pub fn deserialize_with_response(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         162  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         163  +
        _status: u16,
         164  +
        _body: &[u8],
         165  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         166  +
        Self::deserialize(deserializer)
         167  +
    }
         168  +
}
  157    169   
impl GuardrailPiiEntityFilter {
  158    170   
    /// Creates a new builder-style object to manufacture [`GuardrailPiiEntityFilter`](crate::types::GuardrailPiiEntityFilter).
  159    171   
    pub fn builder() -> crate::types::builders::GuardrailPiiEntityFilterBuilder {
  160    172   
        crate::types::builders::GuardrailPiiEntityFilterBuilder::default()
  161    173   
    }
  162    174   
}
  163    175   
  164    176   
/// A builder for [`GuardrailPiiEntityFilter`](crate::types::GuardrailPiiEntityFilter).
  165    177   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  166    178   
#[non_exhaustive]

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

@@ -32,32 +92,92 @@
   52     52   
    "name",
   53     53   
    0,
   54     54   
);
   55     55   
static GUARDRAILREGEXFILTER_MEMBER_MATCH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.bedrockruntime#GuardrailRegexFilter$match",
   58     58   
        "com.amazonaws.bedrockruntime",
   59     59   
        "GuardrailRegexFilter",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "r##match",
          62  +
    "match",
   63     63   
    1,
   64     64   
);
   65     65   
static GUARDRAILREGEXFILTER_MEMBER_REGEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.bedrockruntime#GuardrailRegexFilter$regex",
   68     68   
        "com.amazonaws.bedrockruntime",
   69     69   
        "GuardrailRegexFilter",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72     72   
    "regex",
@@ -107,107 +206,217 @@
  127    127   
            ser.write_string(&GUARDRAILREGEXFILTER_MEMBER_ACTION, val.as_str())?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.detected {
  130    130   
            ser.write_boolean(&GUARDRAILREGEXFILTER_MEMBER_DETECTED, *val)?;
  131    131   
        }
  132    132   
        Ok(())
  133    133   
    }
  134    134   
}
  135    135   
impl GuardrailRegexFilter {
  136    136   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  137         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  138         -
        deserializer: &mut D,
         137  +
    pub fn deserialize(
         138  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  139    139   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  140    140   
        #[allow(unused_variables, unused_mut)]
  141    141   
        let mut builder = Self::builder();
  142    142   
        #[allow(
  143    143   
            unused_variables,
  144    144   
            unreachable_code,
  145    145   
            clippy::single_match,
  146    146   
            clippy::match_single_binding,
  147    147   
            clippy::diverging_sub_expression
  148    148   
        )]
  149         -
        deserializer.read_struct(&GUARDRAILREGEXFILTER_SCHEMA, (), |_, member, deser| {
         149  +
        deserializer.read_struct(&GUARDRAILREGEXFILTER_SCHEMA, &mut |member, deser| {
  150    150   
            match member.member_index() {
  151    151   
                Some(0) => {
  152    152   
                    builder.name = Some(deser.read_string(member)?);
  153    153   
                }
  154    154   
                Some(1) => {
  155    155   
                    builder.r#match = Some(deser.read_string(member)?);
  156    156   
                }
  157    157   
                Some(2) => {
  158    158   
                    builder.regex = Some(deser.read_string(member)?);
  159    159   
                }
  160    160   
                Some(3) => {
  161    161   
                    builder.action = Some(crate::types::GuardrailSensitiveInformationPolicyAction::from(
  162    162   
                        deser.read_string(member)?.as_str(),
  163    163   
                    ));
  164    164   
                }
  165    165   
                Some(4) => {
  166    166   
                    builder.detected = Some(deser.read_boolean(member)?);
  167    167   
                }
  168    168   
                _ => {}
  169    169   
            }
  170    170   
            Ok(())
  171    171   
        })?;
  172    172   
        builder
  173    173   
            .build()
  174    174   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  175    175   
    }
  176    176   
}
         177  +
impl GuardrailRegexFilter {
         178  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         179  +
    pub fn deserialize_with_response(
         180  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         181  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         182  +
        _status: u16,
         183  +
        _body: &[u8],
         184  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         185  +
        Self::deserialize(deserializer)
         186  +
    }
         187  +
}
  177    188   
impl GuardrailRegexFilter {
  178    189   
    /// Creates a new builder-style object to manufacture [`GuardrailRegexFilter`](crate::types::GuardrailRegexFilter).
  179    190   
    pub fn builder() -> crate::types::builders::GuardrailRegexFilterBuilder {
  180    191   
        crate::types::builders::GuardrailRegexFilterBuilder::default()
  181    192   
    }
  182    193   
}
  183    194   
  184    195   
/// A builder for [`GuardrailRegexFilter`](crate::types::GuardrailRegexFilter).
  185    196   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  186    197   
#[non_exhaustive]

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

@@ -6,6 +66,66 @@
   26     26   
    "com.amazonaws.bedrockruntime",
   27     27   
    "GuardrailSensitiveInformationPolicyAssessment",
   28     28   
);
   29     29   
static GUARDRAILSENSITIVEINFORMATIONPOLICYASSESSMENT_MEMBER_PII_ENTITIES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyAssessment$piiEntities",
   32     32   
        "com.amazonaws.bedrockruntime",
   33     33   
        "GuardrailSensitiveInformationPolicyAssessment",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::List,
   36         -
    "pii_entities",
          36  +
    "piiEntities",
   37     37   
    0,
   38     38   
);
   39     39   
static GUARDRAILSENSITIVEINFORMATIONPOLICYASSESSMENT_MEMBER_REGEXES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.bedrockruntime#GuardrailSensitiveInformationPolicyAssessment$regexes",
   42     42   
        "com.amazonaws.bedrockruntime",
   43     43   
        "GuardrailSensitiveInformationPolicyAssessment",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46     46   
    "regexes",
@@ -68,68 +176,183 @@
   88     88   
                    }
   89     89   
                    Ok(())
   90     90   
                },
   91     91   
            )?;
   92     92   
        }
   93     93   
        Ok(())
   94     94   
    }
   95     95   
}
   96     96   
impl GuardrailSensitiveInformationPolicyAssessment {
   97     97   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   98         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   99         -
        deserializer: &mut D,
          98  +
    pub fn deserialize(
          99  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  100    100   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  101    101   
        #[allow(unused_variables, unused_mut)]
  102    102   
        let mut builder = Self::builder();
  103    103   
        #[allow(
  104    104   
            unused_variables,
  105    105   
            unreachable_code,
  106    106   
            clippy::single_match,
  107    107   
            clippy::match_single_binding,
  108    108   
            clippy::diverging_sub_expression
  109    109   
        )]
  110         -
        deserializer.read_struct(&GUARDRAILSENSITIVEINFORMATIONPOLICYASSESSMENT_SCHEMA, (), |_, member, deser| {
         110  +
        deserializer.read_struct(&GUARDRAILSENSITIVEINFORMATIONPOLICYASSESSMENT_SCHEMA, &mut |member, deser| {
  111    111   
            match member.member_index() {
  112    112   
                Some(0) => {
  113    113   
                    builder.pii_entities = Some({
  114         -
                        let container = if let Some(cap) = deser.container_size() {
  115         -
                            Vec::with_capacity(cap)
  116         -
                        } else {
  117         -
                            Vec::new()
  118         -
                        };
  119         -
                        deser.read_list(member, container, |mut list, deser| {
  120         -
                            list.push(crate::types::GuardrailPiiEntityFilter::deserialize(deser)?);
  121         -
                            Ok(list)
  122         -
                        })?
         114  +
                        let mut container = Vec::new();
         115  +
                        deser.read_list(member, &mut |deser| {
         116  +
                            container.push(crate::types::GuardrailPiiEntityFilter::deserialize(deser)?);
         117  +
                            Ok(())
         118  +
                        })?;
         119  +
                        container
  123    120   
                    });
  124    121   
                }
  125    122   
                Some(1) => {
  126    123   
                    builder.regexes = Some({
  127         -
                        let container = if let Some(cap) = deser.container_size() {
  128         -
                            Vec::with_capacity(cap)
  129         -
                        } else {
  130         -
                            Vec::new()
  131         -
                        };
  132         -
                        deser.read_list(member, container, |mut list, deser| {
  133         -
                            list.push(crate::types::GuardrailRegexFilter::deserialize(deser)?);
  134         -
                            Ok(list)
  135         -
                        })?
         124  +
                        let mut container = Vec::new();
         125  +
                        deser.read_list(member, &mut |deser| {
         126  +
                            container.push(crate::types::GuardrailRegexFilter::deserialize(deser)?);
         127  +
                            Ok(())
         128  +
                        })?;
         129  +
                        container
  136    130   
                    });
  137    131   
                }
  138    132   
                _ => {}
  139    133   
            }
  140    134   
            Ok(())
  141    135   
        })?;
         136  +
        builder.pii_entities = builder.pii_entities.or(Some(Vec::new()));
         137  +
        builder.regexes = builder.regexes.or(Some(Vec::new()));
  142    138   
        builder
  143    139   
            .build()
  144    140   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  145    141   
    }
  146    142   
}
         143  +
impl GuardrailSensitiveInformationPolicyAssessment {
         144  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         145  +
    pub fn deserialize_with_response(
         146  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         147  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         148  +
        _status: u16,
         149  +
        _body: &[u8],
         150  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         151  +
        Self::deserialize(deserializer)
         152  +
    }
         153  +
}
  147    154   
impl GuardrailSensitiveInformationPolicyAssessment {
  148    155   
    /// Creates a new builder-style object to manufacture [`GuardrailSensitiveInformationPolicyAssessment`](crate::types::GuardrailSensitiveInformationPolicyAssessment).
  149    156   
    pub fn builder() -> crate::types::builders::GuardrailSensitiveInformationPolicyAssessmentBuilder {
  150    157   
        crate::types::builders::GuardrailSensitiveInformationPolicyAssessmentBuilder::default()
  151    158   
    }
  152    159   
}
  153    160   
  154    161   
/// A builder for [`GuardrailSensitiveInformationPolicyAssessment`](crate::types::GuardrailSensitiveInformationPolicyAssessment).
  155    162   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  156    163   
#[non_exhaustive]

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

@@ -20,20 +188,201 @@
   40     40   
    "com.amazonaws.bedrockruntime",
   41     41   
    "GuardrailStreamConfiguration",
   42     42   
);
   43     43   
static GUARDRAILSTREAMCONFIGURATION_MEMBER_GUARDRAIL_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.bedrockruntime#GuardrailStreamConfiguration$guardrailIdentifier",
   46     46   
        "com.amazonaws.bedrockruntime",
   47     47   
        "GuardrailStreamConfiguration",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "guardrail_identifier",
          50  +
    "guardrailIdentifier",
   51     51   
    0,
   52     52   
);
   53     53   
static GUARDRAILSTREAMCONFIGURATION_MEMBER_GUARDRAIL_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.bedrockruntime#GuardrailStreamConfiguration$guardrailVersion",
   56     56   
        "com.amazonaws.bedrockruntime",
   57     57   
        "GuardrailStreamConfiguration",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "guardrail_version",
          60  +
    "guardrailVersion",
   61     61   
    1,
   62     62   
);
   63     63   
static GUARDRAILSTREAMCONFIGURATION_MEMBER_TRACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "com.amazonaws.bedrockruntime#GuardrailStreamConfiguration$trace",
   66     66   
        "com.amazonaws.bedrockruntime",
   67     67   
        "GuardrailStreamConfiguration",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::String,
   70     70   
    "trace",
   71     71   
    2,
   72     72   
);
   73     73   
static GUARDRAILSTREAMCONFIGURATION_MEMBER_STREAM_PROCESSING_MODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.bedrockruntime#GuardrailStreamConfiguration$streamProcessingMode",
   76     76   
        "com.amazonaws.bedrockruntime",
   77     77   
        "GuardrailStreamConfiguration",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "stream_processing_mode",
          80  +
    "streamProcessingMode",
   81     81   
    3,
   82     82   
);
   83     83   
static GUARDRAILSTREAMCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    GUARDRAILSTREAMCONFIGURATION_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &GUARDRAILSTREAMCONFIGURATION_MEMBER_GUARDRAIL_IDENTIFIER,
   88     88   
        &GUARDRAILSTREAMCONFIGURATION_MEMBER_GUARDRAIL_VERSION,
   89     89   
        &GUARDRAILSTREAMCONFIGURATION_MEMBER_TRACE,
   90     90   
        &GUARDRAILSTREAMCONFIGURATION_MEMBER_STREAM_PROCESSING_MODE,
   91     91   
    ],
   92     92   
);
   93     93   
impl GuardrailStreamConfiguration {
   94     94   
    /// The schema for this shape.
   95     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILSTREAMCONFIGURATION_SCHEMA;
   96     96   
}
   97     97   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailStreamConfiguration {
   98     98   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99     99   
    fn serialize_members(
  100    100   
        &self,
  101    101   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    102   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        {
  104    104   
            let val = &self.guardrail_identifier;
  105    105   
            ser.write_string(&GUARDRAILSTREAMCONFIGURATION_MEMBER_GUARDRAIL_IDENTIFIER, val)?;
  106    106   
        }
  107    107   
        {
  108    108   
            let val = &self.guardrail_version;
  109    109   
            ser.write_string(&GUARDRAILSTREAMCONFIGURATION_MEMBER_GUARDRAIL_VERSION, val)?;
  110    110   
        }
  111    111   
        {
  112    112   
            let val = &self.trace;
  113    113   
            ser.write_string(&GUARDRAILSTREAMCONFIGURATION_MEMBER_TRACE, val.as_str())?;
  114    114   
        }
  115    115   
        {
  116    116   
            let val = &self.stream_processing_mode;
  117    117   
            ser.write_string(&GUARDRAILSTREAMCONFIGURATION_MEMBER_STREAM_PROCESSING_MODE, val.as_str())?;
  118    118   
        }
  119    119   
        Ok(())
  120    120   
    }
  121    121   
}
  122    122   
impl GuardrailStreamConfiguration {
  123    123   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  124         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  125         -
        deserializer: &mut D,
         124  +
    pub fn deserialize(
         125  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  126    126   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  127    127   
        #[allow(unused_variables, unused_mut)]
  128    128   
        let mut builder = Self::builder();
  129    129   
        #[allow(
  130    130   
            unused_variables,
  131    131   
            unreachable_code,
  132    132   
            clippy::single_match,
  133    133   
            clippy::match_single_binding,
  134    134   
            clippy::diverging_sub_expression
  135    135   
        )]
  136         -
        deserializer.read_struct(&GUARDRAILSTREAMCONFIGURATION_SCHEMA, (), |_, member, deser| {
         136  +
        deserializer.read_struct(&GUARDRAILSTREAMCONFIGURATION_SCHEMA, &mut |member, deser| {
  137    137   
            match member.member_index() {
  138    138   
                Some(0) => {
  139    139   
                    builder.guardrail_identifier = Some(deser.read_string(member)?);
  140    140   
                }
  141    141   
                Some(1) => {
  142    142   
                    builder.guardrail_version = Some(deser.read_string(member)?);
  143    143   
                }
  144    144   
                Some(2) => {
  145    145   
                    builder.trace = Some(crate::types::GuardrailTrace::from(deser.read_string(member)?.as_str()));
  146    146   
                }
  147    147   
                Some(3) => {
  148    148   
                    builder.stream_processing_mode = Some(crate::types::GuardrailStreamProcessingMode::from(deser.read_string(member)?.as_str()));
  149    149   
                }
  150    150   
                _ => {}
  151    151   
            }
  152    152   
            Ok(())
  153    153   
        })?;
         154  +
        builder.guardrail_identifier = builder.guardrail_identifier.or(Some(String::new()));
         155  +
        builder.guardrail_version = builder.guardrail_version.or(Some(String::new()));
  154    156   
        builder
  155    157   
            .build()
  156    158   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  157    159   
    }
  158    160   
}
         161  +
impl GuardrailStreamConfiguration {
         162  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         163  +
    pub fn deserialize_with_response(
         164  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         165  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         166  +
        _status: u16,
         167  +
        _body: &[u8],
         168  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         169  +
        Self::deserialize(deserializer)
         170  +
    }
         171  +
}
  159    172   
impl GuardrailStreamConfiguration {
  160    173   
    /// Creates a new builder-style object to manufacture [`GuardrailStreamConfiguration`](crate::types::GuardrailStreamConfiguration).
  161    174   
    pub fn builder() -> crate::types::builders::GuardrailStreamConfigurationBuilder {
  162    175   
        crate::types::builders::GuardrailStreamConfigurationBuilder::default()
  163    176   
    }
  164    177   
}
  165    178   
  166    179   
/// A builder for [`GuardrailStreamConfiguration`](crate::types::GuardrailStreamConfiguration).
  167    180   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  168    181   
#[non_exhaustive]

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

@@ -55,55 +153,162 @@
   75     75   
                    }
   76     76   
                    Ok(())
   77     77   
                },
   78     78   
            )?;
   79     79   
        }
   80     80   
        Ok(())
   81     81   
    }
   82     82   
}
   83     83   
impl GuardrailTextBlock {
   84     84   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   85         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   86         -
        deserializer: &mut D,
          85  +
    pub fn deserialize(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   87     87   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        #[allow(unused_variables, unused_mut)]
   89     89   
        let mut builder = Self::builder();
   90     90   
        #[allow(
   91     91   
            unused_variables,
   92     92   
            unreachable_code,
   93     93   
            clippy::single_match,
   94     94   
            clippy::match_single_binding,
   95     95   
            clippy::diverging_sub_expression
   96     96   
        )]
   97         -
        deserializer.read_struct(&GUARDRAILTEXTBLOCK_SCHEMA, (), |_, member, deser| {
          97  +
        deserializer.read_struct(&GUARDRAILTEXTBLOCK_SCHEMA, &mut |member, deser| {
   98     98   
            match member.member_index() {
   99     99   
                Some(0) => {
  100    100   
                    builder.text = Some(deser.read_string(member)?);
  101    101   
                }
  102    102   
                Some(1) => {
  103    103   
                    builder.qualifiers = Some({
  104         -
                        let container = if let Some(cap) = deser.container_size() {
  105         -
                            Vec::with_capacity(cap)
  106         -
                        } else {
  107         -
                            Vec::new()
  108         -
                        };
  109         -
                        deser.read_list(member, container, |mut list, deser| {
  110         -
                            list.push(crate::types::GuardrailContentQualifier::from(deser.read_string(member)?.as_str()));
  111         -
                            Ok(list)
  112         -
                        })?
         104  +
                        let mut container = Vec::new();
         105  +
                        deser.read_list(member, &mut |deser| {
         106  +
                            container.push(crate::types::GuardrailContentQualifier::from(deser.read_string(member)?.as_str()));
         107  +
                            Ok(())
         108  +
                        })?;
         109  +
                        container
  113    110   
                    });
  114    111   
                }
  115    112   
                _ => {}
  116    113   
            }
  117    114   
            Ok(())
  118    115   
        })?;
         116  +
        builder.text = builder.text.or(Some(String::new()));
  119    117   
        builder
  120    118   
            .build()
  121    119   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  122    120   
    }
  123    121   
}
         122  +
impl GuardrailTextBlock {
         123  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         124  +
    pub fn deserialize_with_response(
         125  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         126  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         127  +
        _status: u16,
         128  +
        _body: &[u8],
         129  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         130  +
        Self::deserialize(deserializer)
         131  +
    }
         132  +
}
  124    133   
impl GuardrailTextBlock {
  125    134   
    /// Creates a new builder-style object to manufacture [`GuardrailTextBlock`](crate::types::GuardrailTextBlock).
  126    135   
    pub fn builder() -> crate::types::builders::GuardrailTextBlockBuilder {
  127    136   
        crate::types::builders::GuardrailTextBlockBuilder::default()
  128    137   
    }
  129    138   
}
  130    139   
  131    140   
/// A builder for [`GuardrailTextBlock`](crate::types::GuardrailTextBlock).
  132    141   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  133    142   
#[non_exhaustive]

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

@@ -46,46 +132,143 @@
   66     66   
            ser.write_integer(&GUARDRAILTEXTCHARACTERSCOVERAGE_MEMBER_GUARDED, *val)?;
   67     67   
        }
   68     68   
        if let Some(ref val) = self.total {
   69     69   
            ser.write_integer(&GUARDRAILTEXTCHARACTERSCOVERAGE_MEMBER_TOTAL, *val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl GuardrailTextCharactersCoverage {
   75     75   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   76         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   77         -
        deserializer: &mut D,
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   78     78   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        #[allow(unused_variables, unused_mut)]
   80     80   
        let mut builder = Self::builder();
   81     81   
        #[allow(
   82     82   
            unused_variables,
   83     83   
            unreachable_code,
   84     84   
            clippy::single_match,
   85     85   
            clippy::match_single_binding,
   86     86   
            clippy::diverging_sub_expression
   87     87   
        )]
   88         -
        deserializer.read_struct(&GUARDRAILTEXTCHARACTERSCOVERAGE_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&GUARDRAILTEXTCHARACTERSCOVERAGE_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.guarded = Some(deser.read_integer(member)?);
   92     92   
                }
   93     93   
                Some(1) => {
   94     94   
                    builder.total = Some(deser.read_integer(member)?);
   95     95   
                }
   96     96   
                _ => {}
   97     97   
            }
   98     98   
            Ok(())
   99     99   
        })?;
  100    100   
        Ok(builder.build())
  101    101   
    }
  102    102   
}
         103  +
impl GuardrailTextCharactersCoverage {
         104  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         105  +
    pub fn deserialize_with_response(
         106  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         107  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         108  +
        _status: u16,
         109  +
        _body: &[u8],
         110  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         111  +
        Self::deserialize(deserializer)
         112  +
    }
         113  +
}
  103    114   
impl GuardrailTextCharactersCoverage {
  104    115   
    /// Creates a new builder-style object to manufacture [`GuardrailTextCharactersCoverage`](crate::types::GuardrailTextCharactersCoverage).
  105    116   
    pub fn builder() -> crate::types::builders::GuardrailTextCharactersCoverageBuilder {
  106    117   
        crate::types::builders::GuardrailTextCharactersCoverageBuilder::default()
  107    118   
    }
  108    119   
}
  109    120   
  110    121   
/// A builder for [`GuardrailTextCharactersCoverage`](crate::types::GuardrailTextCharactersCoverage).
  111    122   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  112    123   
#[non_exhaustive]

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

@@ -27,27 +87,87 @@
   47     47   
    "name",
   48     48   
    0,
   49     49   
);
   50     50   
static GUARDRAILTOPIC_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.bedrockruntime#GuardrailTopic$type",
   53     53   
        "com.amazonaws.bedrockruntime",
   54     54   
        "GuardrailTopic",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "r##type",
          57  +
    "type",
   58     58   
    1,
   59     59   
);
   60     60   
static GUARDRAILTOPIC_MEMBER_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.bedrockruntime#GuardrailTopic$action",
   63     63   
        "com.amazonaws.bedrockruntime",
   64     64   
        "GuardrailTopic",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67     67   
    "action",
@@ -90,90 +184,196 @@
  110    110   
            ser.write_string(&GUARDRAILTOPIC_MEMBER_ACTION, val.as_str())?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.detected {
  113    113   
            ser.write_boolean(&GUARDRAILTOPIC_MEMBER_DETECTED, *val)?;
  114    114   
        }
  115    115   
        Ok(())
  116    116   
    }
  117    117   
}
  118    118   
impl GuardrailTopic {
  119    119   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  120         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  121         -
        deserializer: &mut D,
         120  +
    pub fn deserialize(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  122    122   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        #[allow(unused_variables, unused_mut)]
  124    124   
        let mut builder = Self::builder();
  125    125   
        #[allow(
  126    126   
            unused_variables,
  127    127   
            unreachable_code,
  128    128   
            clippy::single_match,
  129    129   
            clippy::match_single_binding,
  130    130   
            clippy::diverging_sub_expression
  131    131   
        )]
  132         -
        deserializer.read_struct(&GUARDRAILTOPIC_SCHEMA, (), |_, member, deser| {
         132  +
        deserializer.read_struct(&GUARDRAILTOPIC_SCHEMA, &mut |member, deser| {
  133    133   
            match member.member_index() {
  134    134   
                Some(0) => {
  135    135   
                    builder.name = Some(deser.read_string(member)?);
  136    136   
                }
  137    137   
                Some(1) => {
  138    138   
                    builder.r#type = Some(crate::types::GuardrailTopicType::from(deser.read_string(member)?.as_str()));
  139    139   
                }
  140    140   
                Some(2) => {
  141    141   
                    builder.action = Some(crate::types::GuardrailTopicPolicyAction::from(deser.read_string(member)?.as_str()));
  142    142   
                }
  143    143   
                Some(3) => {
  144    144   
                    builder.detected = Some(deser.read_boolean(member)?);
  145    145   
                }
  146    146   
                _ => {}
  147    147   
            }
  148    148   
            Ok(())
  149    149   
        })?;
         150  +
        builder.name = builder.name.or(Some(String::new()));
  150    151   
        builder
  151    152   
            .build()
  152    153   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  153    154   
    }
  154    155   
}
         156  +
impl GuardrailTopic {
         157  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         158  +
    pub fn deserialize_with_response(
         159  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         160  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         161  +
        _status: u16,
         162  +
        _body: &[u8],
         163  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         164  +
        Self::deserialize(deserializer)
         165  +
    }
         166  +
}
  155    167   
impl GuardrailTopic {
  156    168   
    /// Creates a new builder-style object to manufacture [`GuardrailTopic`](crate::types::GuardrailTopic).
  157    169   
    pub fn builder() -> crate::types::builders::GuardrailTopicBuilder {
  158    170   
        crate::types::builders::GuardrailTopicBuilder::default()
  159    171   
    }
  160    172   
}
  161    173   
  162    174   
/// A builder for [`GuardrailTopic`](crate::types::GuardrailTopic).
  163    175   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  164    176   
#[non_exhaustive]

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

@@ -35,35 +130,139 @@
   55     55   
                    }
   56     56   
                    Ok(())
   57     57   
                },
   58     58   
            )?;
   59     59   
        }
   60     60   
        Ok(())
   61     61   
    }
   62     62   
}
   63     63   
impl GuardrailTopicPolicyAssessment {
   64     64   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   65         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   66         -
        deserializer: &mut D,
          65  +
    pub fn deserialize(
          66  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   67     67   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   68     68   
        #[allow(unused_variables, unused_mut)]
   69     69   
        let mut builder = Self::builder();
   70     70   
        #[allow(
   71     71   
            unused_variables,
   72     72   
            unreachable_code,
   73     73   
            clippy::single_match,
   74     74   
            clippy::match_single_binding,
   75     75   
            clippy::diverging_sub_expression
   76     76   
        )]
   77         -
        deserializer.read_struct(&GUARDRAILTOPICPOLICYASSESSMENT_SCHEMA, (), |_, member, deser| {
          77  +
        deserializer.read_struct(&GUARDRAILTOPICPOLICYASSESSMENT_SCHEMA, &mut |member, deser| {
   78     78   
            match member.member_index() {
   79     79   
                Some(0) => {
   80     80   
                    builder.topics = Some({
   81         -
                        let container = if let Some(cap) = deser.container_size() {
   82         -
                            Vec::with_capacity(cap)
   83         -
                        } else {
   84         -
                            Vec::new()
   85         -
                        };
   86         -
                        deser.read_list(member, container, |mut list, deser| {
   87         -
                            list.push(crate::types::GuardrailTopic::deserialize(deser)?);
   88         -
                            Ok(list)
   89         -
                        })?
          81  +
                        let mut container = Vec::new();
          82  +
                        deser.read_list(member, &mut |deser| {
          83  +
                            container.push(crate::types::GuardrailTopic::deserialize(deser)?);
          84  +
                            Ok(())
          85  +
                        })?;
          86  +
                        container
   90     87   
                    });
   91     88   
                }
   92     89   
                _ => {}
   93     90   
            }
   94     91   
            Ok(())
   95     92   
        })?;
          93  +
        builder.topics = builder.topics.or(Some(Vec::new()));
   96     94   
        builder
   97     95   
            .build()
   98     96   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   99     97   
    }
  100     98   
}
          99  +
impl GuardrailTopicPolicyAssessment {
         100  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         101  +
    pub fn deserialize_with_response(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         103  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         104  +
        _status: u16,
         105  +
        _body: &[u8],
         106  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         107  +
        Self::deserialize(deserializer)
         108  +
    }
         109  +
}
  101    110   
impl GuardrailTopicPolicyAssessment {
  102    111   
    /// Creates a new builder-style object to manufacture [`GuardrailTopicPolicyAssessment`](crate::types::GuardrailTopicPolicyAssessment).
  103    112   
    pub fn builder() -> crate::types::builders::GuardrailTopicPolicyAssessmentBuilder {
  104    113   
        crate::types::builders::GuardrailTopicPolicyAssessmentBuilder::default()
  105    114   
    }
  106    115   
}
  107    116   
  108    117   
/// A builder for [`GuardrailTopicPolicyAssessment`](crate::types::GuardrailTopicPolicyAssessment).
  109    118   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  110    119   
#[non_exhaustive]