AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

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

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.bedrockruntime",
   31     31   
    "DocumentCharLocation",
   32     32   
);
   33     33   
static DOCUMENTCHARLOCATION_MEMBER_DOCUMENT_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.bedrockruntime#DocumentCharLocation$documentIndex",
   36     36   
        "com.amazonaws.bedrockruntime",
   37     37   
        "DocumentCharLocation",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "document_index",
          40  +
    "documentIndex",
   41     41   
    0,
   42     42   
);
   43     43   
static DOCUMENTCHARLOCATION_MEMBER_START: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.bedrockruntime#DocumentCharLocation$start",
   46     46   
        "com.amazonaws.bedrockruntime",
   47     47   
        "DocumentCharLocation",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::Integer,
   50     50   
    "start",
   51     51   
    1,
   52     52   
);
   53     53   
static DOCUMENTCHARLOCATION_MEMBER_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.bedrockruntime#DocumentCharLocation$end",
   56     56   
        "com.amazonaws.bedrockruntime",
   57     57   
        "DocumentCharLocation",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Integer,
   60     60   
    "end",
   61     61   
    2,
   62     62   
);
   63     63   
static DOCUMENTCHARLOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    DOCUMENTCHARLOCATION_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &DOCUMENTCHARLOCATION_MEMBER_DOCUMENT_INDEX,
   68     68   
        &DOCUMENTCHARLOCATION_MEMBER_START,
   69     69   
        &DOCUMENTCHARLOCATION_MEMBER_END,
   70     70   
    ],
   71     71   
);
   72     72   
impl DocumentCharLocation {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCUMENTCHARLOCATION_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for DocumentCharLocation {
   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.document_index {
   83     83   
            ser.write_integer(&DOCUMENTCHARLOCATION_MEMBER_DOCUMENT_INDEX, *val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.start {
   86     86   
            ser.write_integer(&DOCUMENTCHARLOCATION_MEMBER_START, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.end {
   89     89   
            ser.write_integer(&DOCUMENTCHARLOCATION_MEMBER_END, *val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl DocumentCharLocation {
   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(&DOCUMENTCHARLOCATION_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&DOCUMENTCHARLOCATION_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.document_index = Some(deser.read_integer(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.start = Some(deser.read_integer(member)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.end = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl DocumentCharLocation {
         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 DocumentCharLocation {
  127    138   
    /// Creates a new builder-style object to manufacture [`DocumentCharLocation`](crate::types::DocumentCharLocation).
  128    139   
    pub fn builder() -> crate::types::builders::DocumentCharLocationBuilder {
  129    140   
        crate::types::builders::DocumentCharLocationBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`DocumentCharLocation`](crate::types::DocumentCharLocation).
  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/_document_chunk_location.rs

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.bedrockruntime",
   31     31   
    "DocumentChunkLocation",
   32     32   
);
   33     33   
static DOCUMENTCHUNKLOCATION_MEMBER_DOCUMENT_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.bedrockruntime#DocumentChunkLocation$documentIndex",
   36     36   
        "com.amazonaws.bedrockruntime",
   37     37   
        "DocumentChunkLocation",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "document_index",
          40  +
    "documentIndex",
   41     41   
    0,
   42     42   
);
   43     43   
static DOCUMENTCHUNKLOCATION_MEMBER_START: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.bedrockruntime#DocumentChunkLocation$start",
   46     46   
        "com.amazonaws.bedrockruntime",
   47     47   
        "DocumentChunkLocation",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::Integer,
   50     50   
    "start",
   51     51   
    1,
   52     52   
);
   53     53   
static DOCUMENTCHUNKLOCATION_MEMBER_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.bedrockruntime#DocumentChunkLocation$end",
   56     56   
        "com.amazonaws.bedrockruntime",
   57     57   
        "DocumentChunkLocation",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Integer,
   60     60   
    "end",
   61     61   
    2,
   62     62   
);
   63     63   
static DOCUMENTCHUNKLOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    DOCUMENTCHUNKLOCATION_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &DOCUMENTCHUNKLOCATION_MEMBER_DOCUMENT_INDEX,
   68     68   
        &DOCUMENTCHUNKLOCATION_MEMBER_START,
   69     69   
        &DOCUMENTCHUNKLOCATION_MEMBER_END,
   70     70   
    ],
   71     71   
);
   72     72   
impl DocumentChunkLocation {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCUMENTCHUNKLOCATION_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for DocumentChunkLocation {
   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.document_index {
   83     83   
            ser.write_integer(&DOCUMENTCHUNKLOCATION_MEMBER_DOCUMENT_INDEX, *val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.start {
   86     86   
            ser.write_integer(&DOCUMENTCHUNKLOCATION_MEMBER_START, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.end {
   89     89   
            ser.write_integer(&DOCUMENTCHUNKLOCATION_MEMBER_END, *val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl DocumentChunkLocation {
   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(&DOCUMENTCHUNKLOCATION_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&DOCUMENTCHUNKLOCATION_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.document_index = Some(deser.read_integer(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.start = Some(deser.read_integer(member)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.end = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl DocumentChunkLocation {
         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 DocumentChunkLocation {
  127    138   
    /// Creates a new builder-style object to manufacture [`DocumentChunkLocation`](crate::types::DocumentChunkLocation).
  128    139   
    pub fn builder() -> crate::types::builders::DocumentChunkLocationBuilder {
  129    140   
        crate::types::builders::DocumentChunkLocationBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`DocumentChunkLocation`](crate::types::DocumentChunkLocation).
  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/_document_content_block.rs

@@ -9,9 +0,94 @@
   29     29   
    }
   30     30   
    /// Returns true if this is a [`Text`](crate::types::DocumentContentBlock::Text).
   31     31   
    pub fn is_text(&self) -> bool {
   32     32   
        self.as_text().is_ok()
   33     33   
    }
   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  +
static DOCUMENTCONTENTBLOCK_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          40  +
    "com.amazonaws.bedrockruntime#DocumentContentBlock",
          41  +
    "com.amazonaws.bedrockruntime",
          42  +
    "DocumentContentBlock",
          43  +
);
          44  +
static DOCUMENTCONTENTBLOCK_MEMBER_TEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          45  +
    ::aws_smithy_schema::ShapeId::from_static(
          46  +
        "com.amazonaws.bedrockruntime#DocumentContentBlock$text",
          47  +
        "com.amazonaws.bedrockruntime",
          48  +
        "DocumentContentBlock",
          49  +
    ),
          50  +
    ::aws_smithy_schema::ShapeType::String,
          51  +
    "text",
          52  +
    0,
          53  +
);
          54  +
static DOCUMENTCONTENTBLOCK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
          55  +
    DOCUMENTCONTENTBLOCK_SCHEMA_ID,
          56  +
    ::aws_smithy_schema::ShapeType::Union,
          57  +
    &[&DOCUMENTCONTENTBLOCK_MEMBER_TEXT],
          58  +
);
          59  +
impl DocumentContentBlock {
          60  +
    /// The schema for this shape.
          61  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCUMENTCONTENTBLOCK_SCHEMA;
          62  +
}
          63  +
impl ::aws_smithy_schema::serde::SerializableStruct for DocumentContentBlock {
          64  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          65  +
    fn serialize_members(
          66  +
        &self,
          67  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          68  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          69  +
        match self {
          70  +
            Self::Text(val) => {
          71  +
                ser.write_string(&DOCUMENTCONTENTBLOCK_MEMBER_TEXT, val)?;
          72  +
            }
          73  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
          74  +
        }
          75  +
        Ok(())
          76  +
    }
          77  +
}
          78  +
impl DocumentContentBlock {
          79  +
    /// Deserializes this union from a [`ShapeDeserializer`].
          80  +
    pub fn deserialize(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          83  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
          84  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
          85  +
        deserializer.read_struct(&DOCUMENTCONTENTBLOCK_SCHEMA, &mut |member, deser| {
          86  +
            result = ::std::option::Option::Some(match member.member_index() {
          87  +
                Some(0) => Self::Text(deser.read_string(member)?),
          88  +
                _ => Self::Unknown,
          89  +
            });
          90  +
            Ok(())
          91  +
        })?;
          92  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
          93  +
    }
          94  +
}

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

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.bedrockruntime",
   31     31   
    "DocumentPageLocation",
   32     32   
);
   33     33   
static DOCUMENTPAGELOCATION_MEMBER_DOCUMENT_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.bedrockruntime#DocumentPageLocation$documentIndex",
   36     36   
        "com.amazonaws.bedrockruntime",
   37     37   
        "DocumentPageLocation",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::Integer,
   40         -
    "document_index",
          40  +
    "documentIndex",
   41     41   
    0,
   42     42   
);
   43     43   
static DOCUMENTPAGELOCATION_MEMBER_START: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.bedrockruntime#DocumentPageLocation$start",
   46     46   
        "com.amazonaws.bedrockruntime",
   47     47   
        "DocumentPageLocation",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::Integer,
   50     50   
    "start",
   51     51   
    1,
   52     52   
);
   53     53   
static DOCUMENTPAGELOCATION_MEMBER_END: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.bedrockruntime#DocumentPageLocation$end",
   56     56   
        "com.amazonaws.bedrockruntime",
   57     57   
        "DocumentPageLocation",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Integer,
   60     60   
    "end",
   61     61   
    2,
   62     62   
);
   63     63   
static DOCUMENTPAGELOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    DOCUMENTPAGELOCATION_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &DOCUMENTPAGELOCATION_MEMBER_DOCUMENT_INDEX,
   68     68   
        &DOCUMENTPAGELOCATION_MEMBER_START,
   69     69   
        &DOCUMENTPAGELOCATION_MEMBER_END,
   70     70   
    ],
   71     71   
);
   72     72   
impl DocumentPageLocation {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCUMENTPAGELOCATION_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for DocumentPageLocation {
   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.document_index {
   83     83   
            ser.write_integer(&DOCUMENTPAGELOCATION_MEMBER_DOCUMENT_INDEX, *val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.start {
   86     86   
            ser.write_integer(&DOCUMENTPAGELOCATION_MEMBER_START, *val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.end {
   89     89   
            ser.write_integer(&DOCUMENTPAGELOCATION_MEMBER_END, *val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl DocumentPageLocation {
   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(&DOCUMENTPAGELOCATION_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&DOCUMENTPAGELOCATION_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.document_index = Some(deser.read_integer(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.start = Some(deser.read_integer(member)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.end = Some(deser.read_integer(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl DocumentPageLocation {
         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 DocumentPageLocation {
  127    138   
    /// Creates a new builder-style object to manufacture [`DocumentPageLocation`](crate::types::DocumentPageLocation).
  128    139   
    pub fn builder() -> crate::types::builders::DocumentPageLocationBuilder {
  129    140   
        crate::types::builders::DocumentPageLocationBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`DocumentPageLocation`](crate::types::DocumentPageLocation).
  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/_document_source.rs

@@ -53,53 +0,200 @@
   73     73   
    }
   74     74   
    /// Returns true if this is a [`Text`](crate::types::DocumentSource::Text).
   75     75   
    pub fn is_text(&self) -> bool {
   76     76   
        self.as_text().is_ok()
   77     77   
    }
   78     78   
    /// Returns true if the enum instance is the `Unknown` variant.
   79     79   
    pub fn is_unknown(&self) -> bool {
   80     80   
        matches!(self, Self::Unknown)
   81     81   
    }
   82     82   
}
          83  +
static DOCUMENTSOURCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
          84  +
    "com.amazonaws.bedrockruntime#DocumentSource",
          85  +
    "com.amazonaws.bedrockruntime",
          86  +
    "DocumentSource",
          87  +
);
          88  +
static DOCUMENTSOURCE_MEMBER_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          89  +
    ::aws_smithy_schema::ShapeId::from_static(
          90  +
        "com.amazonaws.bedrockruntime#DocumentSource$bytes",
          91  +
        "com.amazonaws.bedrockruntime",
          92  +
        "DocumentSource",
          93  +
    ),
          94  +
    ::aws_smithy_schema::ShapeType::Blob,
          95  +
    "bytes",
          96  +
    0,
          97  +
);
          98  +
static DOCUMENTSOURCE_MEMBER_S3LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          99  +
    ::aws_smithy_schema::ShapeId::from_static(
         100  +
        "com.amazonaws.bedrockruntime#DocumentSource$s3Location",
         101  +
        "com.amazonaws.bedrockruntime",
         102  +
        "DocumentSource",
         103  +
    ),
         104  +
    ::aws_smithy_schema::ShapeType::Structure,
         105  +
    "s3Location",
         106  +
    1,
         107  +
);
         108  +
static DOCUMENTSOURCE_MEMBER_TEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         109  +
    ::aws_smithy_schema::ShapeId::from_static(
         110  +
        "com.amazonaws.bedrockruntime#DocumentSource$text",
         111  +
        "com.amazonaws.bedrockruntime",
         112  +
        "DocumentSource",
         113  +
    ),
         114  +
    ::aws_smithy_schema::ShapeType::String,
         115  +
    "text",
         116  +
    2,
         117  +
);
         118  +
static DOCUMENTSOURCE_MEMBER_CONTENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         119  +
    ::aws_smithy_schema::ShapeId::from_static(
         120  +
        "com.amazonaws.bedrockruntime#DocumentSource$content",
         121  +
        "com.amazonaws.bedrockruntime",
         122  +
        "DocumentSource",
         123  +
    ),
         124  +
    ::aws_smithy_schema::ShapeType::List,
         125  +
    "content",
         126  +
    3,
         127  +
);
         128  +
static DOCUMENTSOURCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
         129  +
    DOCUMENTSOURCE_SCHEMA_ID,
         130  +
    ::aws_smithy_schema::ShapeType::Union,
         131  +
    &[
         132  +
        &DOCUMENTSOURCE_MEMBER_BYTES,
         133  +
        &DOCUMENTSOURCE_MEMBER_S3LOCATION,
         134  +
        &DOCUMENTSOURCE_MEMBER_TEXT,
         135  +
        &DOCUMENTSOURCE_MEMBER_CONTENT,
         136  +
    ],
         137  +
);
         138  +
impl DocumentSource {
         139  +
    /// The schema for this shape.
         140  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DOCUMENTSOURCE_SCHEMA;
         141  +
}
         142  +
impl ::aws_smithy_schema::serde::SerializableStruct for DocumentSource {
         143  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         144  +
    fn serialize_members(
         145  +
        &self,
         146  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         147  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         148  +
        match self {
         149  +
            Self::Bytes(val) => {
         150  +
                ser.write_blob(&DOCUMENTSOURCE_MEMBER_BYTES, val)?;
         151  +
            }
         152  +
            Self::S3Location(val) => {
         153  +
                ser.write_struct(&DOCUMENTSOURCE_MEMBER_S3LOCATION, val)?;
         154  +
            }
         155  +
            Self::Text(val) => {
         156  +
                ser.write_string(&DOCUMENTSOURCE_MEMBER_TEXT, val)?;
         157  +
            }
         158  +
            Self::Content(val) => {
         159  +
                ser.write_list(
         160  +
                    &DOCUMENTSOURCE_MEMBER_CONTENT,
         161  +
                    &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         162  +
                        for item in val {
         163  +
                            ser.write_struct(crate::types::DocumentContentBlock::SCHEMA, item)?;
         164  +
                        }
         165  +
                        Ok(())
         166  +
                    },
         167  +
                )?;
         168  +
            }
         169  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         170  +
        }
         171  +
        Ok(())
         172  +
    }
         173  +
}
         174  +
impl DocumentSource {
         175  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         176  +
    pub fn deserialize(
         177  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         178  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         179  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         180  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         181  +
        deserializer.read_struct(&DOCUMENTSOURCE_SCHEMA, &mut |member, deser| {
         182  +
            result = ::std::option::Option::Some(match member.member_index() {
         183  +
                Some(0) => Self::Bytes(deser.read_blob(member)?),
         184  +
                Some(1) => Self::S3Location(crate::types::S3Location::deserialize(deser)?),
         185  +
                Some(2) => Self::Text(deser.read_string(member)?),
         186  +
                Some(3) => Self::Content({
         187  +
                    let mut container = Vec::new();
         188  +
                    deser.read_list(member, &mut |deser| {
         189  +
                        container.push(crate::types::DocumentContentBlock::deserialize(deser)?);
         190  +
                        Ok(())
         191  +
                    })?;
         192  +
                    container
         193  +
                }),
         194  +
                _ => Self::Unknown,
         195  +
            });
         196  +
            Ok(())
         197  +
        })?;
         198  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         199  +
    }
         200  +
}

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

@@ -34,34 +247,258 @@
   54     54   
    "com.amazonaws.bedrockruntime",
   55     55   
    "GuardrailAssessment",
   56     56   
);
   57     57   
static GUARDRAILASSESSMENT_MEMBER_TOPIC_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.bedrockruntime#GuardrailAssessment$topicPolicy",
   60     60   
        "com.amazonaws.bedrockruntime",
   61     61   
        "GuardrailAssessment",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64         -
    "topic_policy",
          64  +
    "topicPolicy",
   65     65   
    0,
   66     66   
);
   67     67   
static GUARDRAILASSESSMENT_MEMBER_CONTENT_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.bedrockruntime#GuardrailAssessment$contentPolicy",
   70     70   
        "com.amazonaws.bedrockruntime",
   71     71   
        "GuardrailAssessment",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Structure,
   74         -
    "content_policy",
          74  +
    "contentPolicy",
   75     75   
    1,
   76     76   
);
   77     77   
static GUARDRAILASSESSMENT_MEMBER_WORD_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.bedrockruntime#GuardrailAssessment$wordPolicy",
   80     80   
        "com.amazonaws.bedrockruntime",
   81     81   
        "GuardrailAssessment",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84         -
    "word_policy",
          84  +
    "wordPolicy",
   85     85   
    2,
   86     86   
);
   87     87   
static GUARDRAILASSESSMENT_MEMBER_SENSITIVE_INFORMATION_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.bedrockruntime#GuardrailAssessment$sensitiveInformationPolicy",
   90     90   
        "com.amazonaws.bedrockruntime",
   91     91   
        "GuardrailAssessment",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::Structure,
   94         -
    "sensitive_information_policy",
          94  +
    "sensitiveInformationPolicy",
   95     95   
    3,
   96     96   
);
   97     97   
static GUARDRAILASSESSMENT_MEMBER_CONTEXTUAL_GROUNDING_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.bedrockruntime#GuardrailAssessment$contextualGroundingPolicy",
  100    100   
        "com.amazonaws.bedrockruntime",
  101    101   
        "GuardrailAssessment",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::Structure,
  104         -
    "contextual_grounding_policy",
         104  +
    "contextualGroundingPolicy",
  105    105   
    4,
  106    106   
);
  107    107   
static GUARDRAILASSESSMENT_MEMBER_AUTOMATED_REASONING_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.bedrockruntime#GuardrailAssessment$automatedReasoningPolicy",
  110    110   
        "com.amazonaws.bedrockruntime",
  111    111   
        "GuardrailAssessment",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::Structure,
  114         -
    "automated_reasoning_policy",
         114  +
    "automatedReasoningPolicy",
  115    115   
    5,
  116    116   
);
  117    117   
static GUARDRAILASSESSMENT_MEMBER_INVOCATION_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.bedrockruntime#GuardrailAssessment$invocationMetrics",
  120    120   
        "com.amazonaws.bedrockruntime",
  121    121   
        "GuardrailAssessment",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::Structure,
  124         -
    "invocation_metrics",
         124  +
    "invocationMetrics",
  125    125   
    6,
  126    126   
);
  127    127   
static GUARDRAILASSESSMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  128    128   
    GUARDRAILASSESSMENT_SCHEMA_ID,
  129    129   
    ::aws_smithy_schema::ShapeType::Structure,
  130    130   
    &[
  131    131   
        &GUARDRAILASSESSMENT_MEMBER_TOPIC_POLICY,
  132    132   
        &GUARDRAILASSESSMENT_MEMBER_CONTENT_POLICY,
  133    133   
        &GUARDRAILASSESSMENT_MEMBER_WORD_POLICY,
  134    134   
        &GUARDRAILASSESSMENT_MEMBER_SENSITIVE_INFORMATION_POLICY,
  135    135   
        &GUARDRAILASSESSMENT_MEMBER_CONTEXTUAL_GROUNDING_POLICY,
  136    136   
        &GUARDRAILASSESSMENT_MEMBER_AUTOMATED_REASONING_POLICY,
  137    137   
        &GUARDRAILASSESSMENT_MEMBER_INVOCATION_METRICS,
  138    138   
    ],
  139    139   
);
  140    140   
impl GuardrailAssessment {
  141    141   
    /// The schema for this shape.
  142    142   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILASSESSMENT_SCHEMA;
  143    143   
}
  144    144   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailAssessment {
  145    145   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  146    146   
    fn serialize_members(
  147    147   
        &self,
  148    148   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  149    149   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  150    150   
        if let Some(ref val) = self.topic_policy {
  151    151   
            ser.write_struct(&GUARDRAILASSESSMENT_MEMBER_TOPIC_POLICY, val)?;
  152    152   
        }
  153    153   
        if let Some(ref val) = self.content_policy {
  154    154   
            ser.write_struct(&GUARDRAILASSESSMENT_MEMBER_CONTENT_POLICY, val)?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.word_policy {
  157    157   
            ser.write_struct(&GUARDRAILASSESSMENT_MEMBER_WORD_POLICY, val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.sensitive_information_policy {
  160    160   
            ser.write_struct(&GUARDRAILASSESSMENT_MEMBER_SENSITIVE_INFORMATION_POLICY, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.contextual_grounding_policy {
  163    163   
            ser.write_struct(&GUARDRAILASSESSMENT_MEMBER_CONTEXTUAL_GROUNDING_POLICY, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.automated_reasoning_policy {
  166    166   
            ser.write_struct(&GUARDRAILASSESSMENT_MEMBER_AUTOMATED_REASONING_POLICY, val)?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.invocation_metrics {
  169    169   
            ser.write_struct(&GUARDRAILASSESSMENT_MEMBER_INVOCATION_METRICS, val)?;
  170    170   
        }
  171    171   
        Ok(())
  172    172   
    }
  173    173   
}
  174    174   
impl GuardrailAssessment {
  175    175   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  176         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  177         -
        deserializer: &mut D,
         176  +
    pub fn deserialize(
         177  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  178    178   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  179    179   
        #[allow(unused_variables, unused_mut)]
  180    180   
        let mut builder = Self::builder();
  181    181   
        #[allow(
  182    182   
            unused_variables,
  183    183   
            unreachable_code,
  184    184   
            clippy::single_match,
  185    185   
            clippy::match_single_binding,
  186    186   
            clippy::diverging_sub_expression
  187    187   
        )]
  188         -
        deserializer.read_struct(&GUARDRAILASSESSMENT_SCHEMA, (), |_, member, deser| {
         188  +
        deserializer.read_struct(&GUARDRAILASSESSMENT_SCHEMA, &mut |member, deser| {
  189    189   
            match member.member_index() {
  190    190   
                Some(0) => {
  191    191   
                    builder.topic_policy = Some(crate::types::GuardrailTopicPolicyAssessment::deserialize(deser)?);
  192    192   
                }
  193    193   
                Some(1) => {
  194    194   
                    builder.content_policy = Some(crate::types::GuardrailContentPolicyAssessment::deserialize(deser)?);
  195    195   
                }
  196    196   
                Some(2) => {
  197    197   
                    builder.word_policy = Some(crate::types::GuardrailWordPolicyAssessment::deserialize(deser)?);
  198    198   
                }
  199    199   
                Some(3) => {
  200    200   
                    builder.sensitive_information_policy = Some(crate::types::GuardrailSensitiveInformationPolicyAssessment::deserialize(deser)?);
  201    201   
                }
  202    202   
                Some(4) => {
  203    203   
                    builder.contextual_grounding_policy = Some(crate::types::GuardrailContextualGroundingPolicyAssessment::deserialize(deser)?);
  204    204   
                }
  205    205   
                Some(5) => {
  206    206   
                    builder.automated_reasoning_policy = Some(crate::types::GuardrailAutomatedReasoningPolicyAssessment::deserialize(deser)?);
  207    207   
                }
  208    208   
                Some(6) => {
  209    209   
                    builder.invocation_metrics = Some(crate::types::GuardrailInvocationMetrics::deserialize(deser)?);
  210    210   
                }
  211    211   
                _ => {}
  212    212   
            }
  213    213   
            Ok(())
  214    214   
        })?;
  215    215   
        Ok(builder.build())
  216    216   
    }
  217    217   
}
         218  +
impl GuardrailAssessment {
         219  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         220  +
    pub fn deserialize_with_response(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         222  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         223  +
        _status: u16,
         224  +
        _body: &[u8],
         225  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         226  +
        Self::deserialize(deserializer)
         227  +
    }
         228  +
}
  218    229   
impl GuardrailAssessment {
  219    230   
    /// Creates a new builder-style object to manufacture [`GuardrailAssessment`](crate::types::GuardrailAssessment).
  220    231   
    pub fn builder() -> crate::types::builders::GuardrailAssessmentBuilder {
  221    232   
        crate::types::builders::GuardrailAssessmentBuilder::default()
  222    233   
    }
  223    234   
}
  224    235   
  225    236   
/// A builder for [`GuardrailAssessment`](crate::types::GuardrailAssessment).
  226    237   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  227    238   
#[non_exhaustive]

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

@@ -98,98 +0,275 @@
  118    118   
    }
  119    119   
    /// Returns true if this is a [`Valid`](crate::types::GuardrailAutomatedReasoningFinding::Valid).
  120    120   
    pub fn is_valid(&self) -> bool {
  121    121   
        self.as_valid().is_ok()
  122    122   
    }
  123    123   
    /// Returns true if the enum instance is the `Unknown` variant.
  124    124   
    pub fn is_unknown(&self) -> bool {
  125    125   
        matches!(self, Self::Unknown)
  126    126   
    }
  127    127   
}
         128  +
static GUARDRAILAUTOMATEDREASONINGFINDING_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
         129  +
    "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding",
         130  +
    "com.amazonaws.bedrockruntime",
         131  +
    "GuardrailAutomatedReasoningFinding",
         132  +
);
         133  +
static GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_VALID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         134  +
    ::aws_smithy_schema::ShapeId::from_static(
         135  +
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding$valid",
         136  +
        "com.amazonaws.bedrockruntime",
         137  +
        "GuardrailAutomatedReasoningFinding",
         138  +
    ),
         139  +
    ::aws_smithy_schema::ShapeType::Structure,
         140  +
    "valid",
         141  +
    0,
         142  +
);
         143  +
static GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_INVALID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         144  +
    ::aws_smithy_schema::ShapeId::from_static(
         145  +
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding$invalid",
         146  +
        "com.amazonaws.bedrockruntime",
         147  +
        "GuardrailAutomatedReasoningFinding",
         148  +
    ),
         149  +
    ::aws_smithy_schema::ShapeType::Structure,
         150  +
    "invalid",
         151  +
    1,
         152  +
);
         153  +
static GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_SATISFIABLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         154  +
    ::aws_smithy_schema::ShapeId::from_static(
         155  +
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding$satisfiable",
         156  +
        "com.amazonaws.bedrockruntime",
         157  +
        "GuardrailAutomatedReasoningFinding",
         158  +
    ),
         159  +
    ::aws_smithy_schema::ShapeType::Structure,
         160  +
    "satisfiable",
         161  +
    2,
         162  +
);
         163  +
static GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_IMPOSSIBLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         164  +
    ::aws_smithy_schema::ShapeId::from_static(
         165  +
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding$impossible",
         166  +
        "com.amazonaws.bedrockruntime",
         167  +
        "GuardrailAutomatedReasoningFinding",
         168  +
    ),
         169  +
    ::aws_smithy_schema::ShapeType::Structure,
         170  +
    "impossible",
         171  +
    3,
         172  +
);
         173  +
static GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_TRANSLATIONAMBIGUOUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         174  +
    ::aws_smithy_schema::ShapeId::from_static(
         175  +
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding$translationAmbiguous",
         176  +
        "com.amazonaws.bedrockruntime",
         177  +
        "GuardrailAutomatedReasoningFinding",
         178  +
    ),
         179  +
    ::aws_smithy_schema::ShapeType::Structure,
         180  +
    "translationAmbiguous",
         181  +
    4,
         182  +
);
         183  +
static GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_TOOCOMPLEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         184  +
    ::aws_smithy_schema::ShapeId::from_static(
         185  +
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding$tooComplex",
         186  +
        "com.amazonaws.bedrockruntime",
         187  +
        "GuardrailAutomatedReasoningFinding",
         188  +
    ),
         189  +
    ::aws_smithy_schema::ShapeType::Structure,
         190  +
    "tooComplex",
         191  +
    5,
         192  +
);
         193  +
static GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_NOTRANSLATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         194  +
    ::aws_smithy_schema::ShapeId::from_static(
         195  +
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningFinding$noTranslations",
         196  +
        "com.amazonaws.bedrockruntime",
         197  +
        "GuardrailAutomatedReasoningFinding",
         198  +
    ),
         199  +
    ::aws_smithy_schema::ShapeType::Structure,
         200  +
    "noTranslations",
         201  +
    6,
         202  +
);
         203  +
static GUARDRAILAUTOMATEDREASONINGFINDING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
         204  +
    GUARDRAILAUTOMATEDREASONINGFINDING_SCHEMA_ID,
         205  +
    ::aws_smithy_schema::ShapeType::Union,
         206  +
    &[
         207  +
        &GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_VALID,
         208  +
        &GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_INVALID,
         209  +
        &GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_SATISFIABLE,
         210  +
        &GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_IMPOSSIBLE,
         211  +
        &GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_TRANSLATIONAMBIGUOUS,
         212  +
        &GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_TOOCOMPLEX,
         213  +
        &GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_NOTRANSLATIONS,
         214  +
    ],
         215  +
);
         216  +
impl GuardrailAutomatedReasoningFinding {
         217  +
    /// The schema for this shape.
         218  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILAUTOMATEDREASONINGFINDING_SCHEMA;
         219  +
}
         220  +
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailAutomatedReasoningFinding {
         221  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         222  +
    fn serialize_members(
         223  +
        &self,
         224  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         225  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         226  +
        match self {
         227  +
            Self::Valid(val) => {
         228  +
                ser.write_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_VALID, val)?;
         229  +
            }
         230  +
            Self::Invalid(val) => {
         231  +
                ser.write_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_INVALID, val)?;
         232  +
            }
         233  +
            Self::Satisfiable(val) => {
         234  +
                ser.write_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_SATISFIABLE, val)?;
         235  +
            }
         236  +
            Self::Impossible(val) => {
         237  +
                ser.write_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_IMPOSSIBLE, val)?;
         238  +
            }
         239  +
            Self::TranslationAmbiguous(val) => {
         240  +
                ser.write_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_TRANSLATIONAMBIGUOUS, val)?;
         241  +
            }
         242  +
            Self::TooComplex(val) => {
         243  +
                ser.write_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_TOOCOMPLEX, val)?;
         244  +
            }
         245  +
            Self::NoTranslations(val) => {
         246  +
                ser.write_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_MEMBER_NOTRANSLATIONS, val)?;
         247  +
            }
         248  +
            Self::Unknown => return Err(::aws_smithy_schema::serde::SerdeError::custom("cannot serialize unknown union variant")),
         249  +
        }
         250  +
        Ok(())
         251  +
    }
         252  +
}
         253  +
impl GuardrailAutomatedReasoningFinding {
         254  +
    /// Deserializes this union from a [`ShapeDeserializer`].
         255  +
    pub fn deserialize(
         256  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         257  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         258  +
        let mut result: ::std::option::Option<Self> = ::std::option::Option::None;
         259  +
        #[allow(unused_variables, unreachable_code, clippy::single_match, clippy::match_single_binding)]
         260  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGFINDING_SCHEMA, &mut |member, deser| {
         261  +
            result = ::std::option::Option::Some(match member.member_index() {
         262  +
                Some(0) => Self::Valid(crate::types::GuardrailAutomatedReasoningValidFinding::deserialize(deser)?),
         263  +
                Some(1) => Self::Invalid(crate::types::GuardrailAutomatedReasoningInvalidFinding::deserialize(deser)?),
         264  +
                Some(2) => Self::Satisfiable(crate::types::GuardrailAutomatedReasoningSatisfiableFinding::deserialize(deser)?),
         265  +
                Some(3) => Self::Impossible(crate::types::GuardrailAutomatedReasoningImpossibleFinding::deserialize(deser)?),
         266  +
                Some(4) => Self::TranslationAmbiguous(crate::types::GuardrailAutomatedReasoningTranslationAmbiguousFinding::deserialize(deser)?),
         267  +
                Some(5) => Self::TooComplex(crate::types::GuardrailAutomatedReasoningTooComplexFinding::deserialize(deser)?),
         268  +
                Some(6) => Self::NoTranslations(crate::types::GuardrailAutomatedReasoningNoTranslationsFinding::deserialize(deser)?),
         269  +
                _ => Self::Unknown,
         270  +
            });
         271  +
            Ok(())
         272  +
        })?;
         273  +
        result.ok_or_else(|| ::aws_smithy_schema::serde::SerdeError::custom("expected a union variant"))
         274  +
    }
         275  +
}

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

@@ -22,22 +175,183 @@
   42     42   
    "translation",
   43     43   
    0,
   44     44   
);
   45     45   
static GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_CONTRADICTING_RULES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningImpossibleFinding$contradictingRules",
   48     48   
        "com.amazonaws.bedrockruntime",
   49     49   
        "GuardrailAutomatedReasoningImpossibleFinding",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::List,
   52         -
    "contradicting_rules",
          52  +
    "contradictingRules",
   53     53   
    1,
   54     54   
);
   55     55   
static GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_LOGIC_WARNING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningImpossibleFinding$logicWarning",
   58     58   
        "com.amazonaws.bedrockruntime",
   59     59   
        "GuardrailAutomatedReasoningImpossibleFinding",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Structure,
   62         -
    "logic_warning",
          62  +
    "logicWarning",
   63     63   
    2,
   64     64   
);
   65     65   
static GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_TRANSLATION,
   70     70   
        &GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_CONTRADICTING_RULES,
   71     71   
        &GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_LOGIC_WARNING,
   72     72   
    ],
   73     73   
);
   74     74   
impl GuardrailAutomatedReasoningImpossibleFinding {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailAutomatedReasoningImpossibleFinding {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        if let Some(ref val) = self.translation {
   85     85   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_TRANSLATION, val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.contradicting_rules {
   88     88   
            ser.write_list(
   89     89   
                &GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_CONTRADICTING_RULES,
   90     90   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   91     91   
                    for item in val {
   92     92   
                        ser.write_struct(crate::types::GuardrailAutomatedReasoningRule::SCHEMA, item)?;
   93     93   
                    }
   94     94   
                    Ok(())
   95     95   
                },
   96     96   
            )?;
   97     97   
        }
   98     98   
        if let Some(ref val) = self.logic_warning {
   99     99   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_MEMBER_LOGIC_WARNING, val)?;
  100    100   
        }
  101    101   
        Ok(())
  102    102   
    }
  103    103   
}
  104    104   
impl GuardrailAutomatedReasoningImpossibleFinding {
  105    105   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  106         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  107         -
        deserializer: &mut D,
         106  +
    pub fn deserialize(
         107  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  108    108   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  109    109   
        #[allow(unused_variables, unused_mut)]
  110    110   
        let mut builder = Self::builder();
  111    111   
        #[allow(
  112    112   
            unused_variables,
  113    113   
            unreachable_code,
  114    114   
            clippy::single_match,
  115    115   
            clippy::match_single_binding,
  116    116   
            clippy::diverging_sub_expression
  117    117   
        )]
  118         -
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_SCHEMA, (), |_, member, deser| {
         118  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGIMPOSSIBLEFINDING_SCHEMA, &mut |member, deser| {
  119    119   
            match member.member_index() {
  120    120   
                Some(0) => {
  121    121   
                    builder.translation = Some(crate::types::GuardrailAutomatedReasoningTranslation::deserialize(deser)?);
  122    122   
                }
  123    123   
                Some(1) => {
  124    124   
                    builder.contradicting_rules = Some({
  125         -
                        let container = if let Some(cap) = deser.container_size() {
  126         -
                            Vec::with_capacity(cap)
  127         -
                        } else {
  128         -
                            Vec::new()
  129         -
                        };
  130         -
                        deser.read_list(member, container, |mut list, deser| {
  131         -
                            list.push(crate::types::GuardrailAutomatedReasoningRule::deserialize(deser)?);
  132         -
                            Ok(list)
  133         -
                        })?
         125  +
                        let mut container = Vec::new();
         126  +
                        deser.read_list(member, &mut |deser| {
         127  +
                            container.push(crate::types::GuardrailAutomatedReasoningRule::deserialize(deser)?);
         128  +
                            Ok(())
         129  +
                        })?;
         130  +
                        container
  134    131   
                    });
  135    132   
                }
  136    133   
                Some(2) => {
  137    134   
                    builder.logic_warning = Some(crate::types::GuardrailAutomatedReasoningLogicWarning::deserialize(deser)?);
  138    135   
                }
  139    136   
                _ => {}
  140    137   
            }
  141    138   
            Ok(())
  142    139   
        })?;
  143    140   
        Ok(builder.build())
  144    141   
    }
  145    142   
}
         143  +
impl GuardrailAutomatedReasoningImpossibleFinding {
         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  +
}
  146    154   
impl GuardrailAutomatedReasoningImpossibleFinding {
  147    155   
    /// Creates a new builder-style object to manufacture [`GuardrailAutomatedReasoningImpossibleFinding`](crate::types::GuardrailAutomatedReasoningImpossibleFinding).
  148    156   
    pub fn builder() -> crate::types::builders::GuardrailAutomatedReasoningImpossibleFindingBuilder {
  149    157   
        crate::types::builders::GuardrailAutomatedReasoningImpossibleFindingBuilder::default()
  150    158   
    }
  151    159   
}
  152    160   
  153    161   
/// A builder for [`GuardrailAutomatedReasoningImpossibleFinding`](crate::types::GuardrailAutomatedReasoningImpossibleFinding).
  154    162   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  155    163   
#[non_exhaustive]

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

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

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

@@ -22,22 +175,183 @@
   42     42   
    "translation",
   43     43   
    0,
   44     44   
);
   45     45   
static GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_CONTRADICTING_RULES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInvalidFinding$contradictingRules",
   48     48   
        "com.amazonaws.bedrockruntime",
   49     49   
        "GuardrailAutomatedReasoningInvalidFinding",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::List,
   52         -
    "contradicting_rules",
          52  +
    "contradictingRules",
   53     53   
    1,
   54     54   
);
   55     55   
static GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_LOGIC_WARNING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningInvalidFinding$logicWarning",
   58     58   
        "com.amazonaws.bedrockruntime",
   59     59   
        "GuardrailAutomatedReasoningInvalidFinding",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::Structure,
   62         -
    "logic_warning",
          62  +
    "logicWarning",
   63     63   
    2,
   64     64   
);
   65     65   
static GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_TRANSLATION,
   70     70   
        &GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_CONTRADICTING_RULES,
   71     71   
        &GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_LOGIC_WARNING,
   72     72   
    ],
   73     73   
);
   74     74   
impl GuardrailAutomatedReasoningInvalidFinding {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailAutomatedReasoningInvalidFinding {
   79     79   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   80     80   
    fn serialize_members(
   81     81   
        &self,
   82     82   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   83     83   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   84     84   
        if let Some(ref val) = self.translation {
   85     85   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_TRANSLATION, val)?;
   86     86   
        }
   87     87   
        if let Some(ref val) = self.contradicting_rules {
   88     88   
            ser.write_list(
   89     89   
                &GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_CONTRADICTING_RULES,
   90     90   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   91     91   
                    for item in val {
   92     92   
                        ser.write_struct(crate::types::GuardrailAutomatedReasoningRule::SCHEMA, item)?;
   93     93   
                    }
   94     94   
                    Ok(())
   95     95   
                },
   96     96   
            )?;
   97     97   
        }
   98     98   
        if let Some(ref val) = self.logic_warning {
   99     99   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_MEMBER_LOGIC_WARNING, val)?;
  100    100   
        }
  101    101   
        Ok(())
  102    102   
    }
  103    103   
}
  104    104   
impl GuardrailAutomatedReasoningInvalidFinding {
  105    105   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  106         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  107         -
        deserializer: &mut D,
         106  +
    pub fn deserialize(
         107  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  108    108   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  109    109   
        #[allow(unused_variables, unused_mut)]
  110    110   
        let mut builder = Self::builder();
  111    111   
        #[allow(
  112    112   
            unused_variables,
  113    113   
            unreachable_code,
  114    114   
            clippy::single_match,
  115    115   
            clippy::match_single_binding,
  116    116   
            clippy::diverging_sub_expression
  117    117   
        )]
  118         -
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_SCHEMA, (), |_, member, deser| {
         118  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGINVALIDFINDING_SCHEMA, &mut |member, deser| {
  119    119   
            match member.member_index() {
  120    120   
                Some(0) => {
  121    121   
                    builder.translation = Some(crate::types::GuardrailAutomatedReasoningTranslation::deserialize(deser)?);
  122    122   
                }
  123    123   
                Some(1) => {
  124    124   
                    builder.contradicting_rules = Some({
  125         -
                        let container = if let Some(cap) = deser.container_size() {
  126         -
                            Vec::with_capacity(cap)
  127         -
                        } else {
  128         -
                            Vec::new()
  129         -
                        };
  130         -
                        deser.read_list(member, container, |mut list, deser| {
  131         -
                            list.push(crate::types::GuardrailAutomatedReasoningRule::deserialize(deser)?);
  132         -
                            Ok(list)
  133         -
                        })?
         125  +
                        let mut container = Vec::new();
         126  +
                        deser.read_list(member, &mut |deser| {
         127  +
                            container.push(crate::types::GuardrailAutomatedReasoningRule::deserialize(deser)?);
         128  +
                            Ok(())
         129  +
                        })?;
         130  +
                        container
  134    131   
                    });
  135    132   
                }
  136    133   
                Some(2) => {
  137    134   
                    builder.logic_warning = Some(crate::types::GuardrailAutomatedReasoningLogicWarning::deserialize(deser)?);
  138    135   
                }
  139    136   
                _ => {}
  140    137   
            }
  141    138   
            Ok(())
  142    139   
        })?;
  143    140   
        Ok(builder.build())
  144    141   
    }
  145    142   
}
         143  +
impl GuardrailAutomatedReasoningInvalidFinding {
         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  +
}
  146    154   
impl GuardrailAutomatedReasoningInvalidFinding {
  147    155   
    /// Creates a new builder-style object to manufacture [`GuardrailAutomatedReasoningInvalidFinding`](crate::types::GuardrailAutomatedReasoningInvalidFinding).
  148    156   
    pub fn builder() -> crate::types::builders::GuardrailAutomatedReasoningInvalidFindingBuilder {
  149    157   
        crate::types::builders::GuardrailAutomatedReasoningInvalidFindingBuilder::default()
  150    158   
    }
  151    159   
}
  152    160   
  153    161   
/// A builder for [`GuardrailAutomatedReasoningInvalidFinding`](crate::types::GuardrailAutomatedReasoningInvalidFinding).
  154    162   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  155    163   
#[non_exhaustive]

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

@@ -14,14 +74,74 @@
   34     34   
    "com.amazonaws.bedrockruntime",
   35     35   
    "GuardrailAutomatedReasoningLogicWarning",
   36     36   
);
   37     37   
static GUARDRAILAUTOMATEDREASONINGLOGICWARNING_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningLogicWarning$type",
   40     40   
        "com.amazonaws.bedrockruntime",
   41     41   
        "GuardrailAutomatedReasoningLogicWarning",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "r##type",
          44  +
    "type",
   45     45   
    0,
   46     46   
);
   47     47   
static GUARDRAILAUTOMATEDREASONINGLOGICWARNING_MEMBER_PREMISES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningLogicWarning$premises",
   50     50   
        "com.amazonaws.bedrockruntime",
   51     51   
        "GuardrailAutomatedReasoningLogicWarning",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::List,
   54     54   
    "premises",
@@ -86,86 +197,202 @@
  106    106   
                    }
  107    107   
                    Ok(())
  108    108   
                },
  109    109   
            )?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl GuardrailAutomatedReasoningLogicWarning {
  115    115   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  116         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  117         -
        deserializer: &mut D,
         116  +
    pub fn deserialize(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  118    118   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        #[allow(unused_variables, unused_mut)]
  120    120   
        let mut builder = Self::builder();
  121    121   
        #[allow(
  122    122   
            unused_variables,
  123    123   
            unreachable_code,
  124    124   
            clippy::single_match,
  125    125   
            clippy::match_single_binding,
  126    126   
            clippy::diverging_sub_expression
  127    127   
        )]
  128         -
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGLOGICWARNING_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGLOGICWARNING_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.r#type = Some(crate::types::GuardrailAutomatedReasoningLogicWarningType::from(
  132    132   
                        deser.read_string(member)?.as_str(),
  133    133   
                    ));
  134    134   
                }
  135    135   
                Some(1) => {
  136    136   
                    builder.premises = Some({
  137         -
                        let container = if let Some(cap) = deser.container_size() {
  138         -
                            Vec::with_capacity(cap)
  139         -
                        } else {
  140         -
                            Vec::new()
  141         -
                        };
  142         -
                        deser.read_list(member, container, |mut list, deser| {
  143         -
                            list.push(crate::types::GuardrailAutomatedReasoningStatement::deserialize(deser)?);
  144         -
                            Ok(list)
  145         -
                        })?
         137  +
                        let mut container = Vec::new();
         138  +
                        deser.read_list(member, &mut |deser| {
         139  +
                            container.push(crate::types::GuardrailAutomatedReasoningStatement::deserialize(deser)?);
         140  +
                            Ok(())
         141  +
                        })?;
         142  +
                        container
  146    143   
                    });
  147    144   
                }
  148    145   
                Some(2) => {
  149    146   
                    builder.claims = Some({
  150         -
                        let container = if let Some(cap) = deser.container_size() {
  151         -
                            Vec::with_capacity(cap)
  152         -
                        } else {
  153         -
                            Vec::new()
  154         -
                        };
  155         -
                        deser.read_list(member, container, |mut list, deser| {
  156         -
                            list.push(crate::types::GuardrailAutomatedReasoningStatement::deserialize(deser)?);
  157         -
                            Ok(list)
  158         -
                        })?
         147  +
                        let mut container = Vec::new();
         148  +
                        deser.read_list(member, &mut |deser| {
         149  +
                            container.push(crate::types::GuardrailAutomatedReasoningStatement::deserialize(deser)?);
         150  +
                            Ok(())
         151  +
                        })?;
         152  +
                        container
  159    153   
                    });
  160    154   
                }
  161    155   
                _ => {}
  162    156   
            }
  163    157   
            Ok(())
  164    158   
        })?;
  165    159   
        Ok(builder.build())
  166    160   
    }
  167    161   
}
         162  +
impl GuardrailAutomatedReasoningLogicWarning {
         163  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         164  +
    pub fn deserialize_with_response(
         165  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         166  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         167  +
        _status: u16,
         168  +
        _body: &[u8],
         169  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         170  +
        Self::deserialize(deserializer)
         171  +
    }
         172  +
}
  168    173   
impl GuardrailAutomatedReasoningLogicWarning {
  169    174   
    /// Creates a new builder-style object to manufacture [`GuardrailAutomatedReasoningLogicWarning`](crate::types::GuardrailAutomatedReasoningLogicWarning).
  170    175   
    pub fn builder() -> crate::types::builders::GuardrailAutomatedReasoningLogicWarningBuilder {
  171    176   
        crate::types::builders::GuardrailAutomatedReasoningLogicWarningBuilder::default()
  172    177   
    }
  173    178   
}
  174    179   
  175    180   
/// A builder for [`GuardrailAutomatedReasoningLogicWarning`](crate::types::GuardrailAutomatedReasoningLogicWarning).
  176    181   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  177    182   
#[non_exhaustive]

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

@@ -2,2 +69,80 @@
   22     22   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   23     23   
    fn serialize_members(
   24     24   
        &self,
   25     25   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   26     26   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   27     27   
        Ok(())
   28     28   
    }
   29     29   
}
   30     30   
impl GuardrailAutomatedReasoningNoTranslationsFinding {
   31     31   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   32         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   33         -
        deserializer: &mut D,
          32  +
    pub fn deserialize(
          33  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   34     34   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   35     35   
        #[allow(unused_variables, unused_mut)]
   36     36   
        let mut builder = Self::builder();
   37     37   
        #[allow(
   38     38   
            unused_variables,
   39     39   
            unreachable_code,
   40     40   
            clippy::single_match,
   41     41   
            clippy::match_single_binding,
   42     42   
            clippy::diverging_sub_expression
   43     43   
        )]
   44         -
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGNOTRANSLATIONSFINDING_SCHEMA, (), |_, member, deser| {
          44  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGNOTRANSLATIONSFINDING_SCHEMA, &mut |member, deser| {
   45     45   
            match member.member_index() {
   46     46   
                _ => {}
   47     47   
            }
   48     48   
            Ok(())
   49     49   
        })?;
   50     50   
        Ok(builder.build())
   51     51   
    }
   52     52   
}
          53  +
impl GuardrailAutomatedReasoningNoTranslationsFinding {
          54  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          55  +
    pub fn deserialize_with_response(
          56  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          57  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          58  +
        _status: u16,
          59  +
        _body: &[u8],
          60  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          61  +
        Ok(Self::builder().build())
          62  +
    }
          63  +
}
   53     64   
impl GuardrailAutomatedReasoningNoTranslationsFinding {
   54     65   
    /// Creates a new builder-style object to manufacture [`GuardrailAutomatedReasoningNoTranslationsFinding`](crate::types::GuardrailAutomatedReasoningNoTranslationsFinding).
   55     66   
    pub fn builder() -> crate::types::builders::GuardrailAutomatedReasoningNoTranslationsFindingBuilder {
   56     67   
        crate::types::builders::GuardrailAutomatedReasoningNoTranslationsFindingBuilder::default()
   57     68   
    }
   58     69   
}
   59     70   
   60     71   
/// A builder for [`GuardrailAutomatedReasoningNoTranslationsFinding`](crate::types::GuardrailAutomatedReasoningNoTranslationsFinding).
   61     72   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   62     73   
#[non_exhaustive]

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

@@ -23,23 +127,135 @@
   43     43   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     44   
    fn serialize_members(
   45     45   
        &self,
   46     46   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     47   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     48   
        if let Some(ref val) = self.findings {
   49     49   
            ser.write_list(
   50     50   
                &GUARDRAILAUTOMATEDREASONINGPOLICYASSESSMENT_MEMBER_FINDINGS,
   51     51   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   52     52   
                    for item in val {
   53         -
                        todo!("schema: unsupported list element type");
          53  +
                        ser.write_struct(crate::types::GuardrailAutomatedReasoningFinding::SCHEMA, item)?;
   54     54   
                    }
   55     55   
                    Ok(())
   56     56   
                },
   57     57   
            )?;
   58     58   
        }
   59     59   
        Ok(())
   60     60   
    }
   61     61   
}
   62     62   
impl GuardrailAutomatedReasoningPolicyAssessment {
   63     63   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   64         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   65         -
        deserializer: &mut D,
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   66     66   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   67     67   
        #[allow(unused_variables, unused_mut)]
   68     68   
        let mut builder = Self::builder();
   69     69   
        #[allow(
   70     70   
            unused_variables,
   71     71   
            unreachable_code,
   72     72   
            clippy::single_match,
   73     73   
            clippy::match_single_binding,
   74     74   
            clippy::diverging_sub_expression
   75     75   
        )]
   76         -
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGPOLICYASSESSMENT_SCHEMA, (), |_, member, deser| {
          76  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGPOLICYASSESSMENT_SCHEMA, &mut |member, deser| {
   77     77   
            match member.member_index() {
   78     78   
                Some(0) => {
   79     79   
                    builder.findings = Some({
   80         -
                        let container = if let Some(cap) = deser.container_size() {
   81         -
                            Vec::with_capacity(cap)
   82         -
                        } else {
   83         -
                            Vec::new()
   84         -
                        };
   85         -
                        deser.read_list(member, container, |mut list, deser| {
   86         -
                            list.push(todo!("deserialize nested aggregate"));
   87         -
                            Ok(list)
   88         -
                        })?
          80  +
                        let mut container = Vec::new();
          81  +
                        deser.read_list(member, &mut |deser| {
          82  +
                            container.push(crate::types::GuardrailAutomatedReasoningFinding::deserialize(deser)?);
          83  +
                            Ok(())
          84  +
                        })?;
          85  +
                        container
   89     86   
                    });
   90     87   
                }
   91     88   
                _ => {}
   92     89   
            }
   93     90   
            Ok(())
   94     91   
        })?;
   95     92   
        Ok(builder.build())
   96     93   
    }
   97     94   
}
          95  +
impl GuardrailAutomatedReasoningPolicyAssessment {
          96  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          97  +
    pub fn deserialize_with_response(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          99  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         100  +
        _status: u16,
         101  +
        _body: &[u8],
         102  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         103  +
        Self::deserialize(deserializer)
         104  +
    }
         105  +
}
   98    106   
impl GuardrailAutomatedReasoningPolicyAssessment {
   99    107   
    /// Creates a new builder-style object to manufacture [`GuardrailAutomatedReasoningPolicyAssessment`](crate::types::GuardrailAutomatedReasoningPolicyAssessment).
  100    108   
    pub fn builder() -> crate::types::builders::GuardrailAutomatedReasoningPolicyAssessmentBuilder {
  101    109   
        crate::types::builders::GuardrailAutomatedReasoningPolicyAssessmentBuilder::default()
  102    110   
    }
  103    111   
}
  104    112   
  105    113   
/// A builder for [`GuardrailAutomatedReasoningPolicyAssessment`](crate::types::GuardrailAutomatedReasoningPolicyAssessment).
  106    114   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  107    115   
#[non_exhaustive]

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

@@ -14,14 +132,143 @@
   34     34   
    "identifier",
   35     35   
    0,
   36     36   
);
   37     37   
static GUARDRAILAUTOMATEDREASONINGRULE_MEMBER_POLICY_VERSION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningRule$policyVersionArn",
   40     40   
        "com.amazonaws.bedrockruntime",
   41     41   
        "GuardrailAutomatedReasoningRule",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "policy_version_arn",
          44  +
    "policyVersionArn",
   45     45   
    1,
   46     46   
);
   47     47   
static GUARDRAILAUTOMATEDREASONINGRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    GUARDRAILAUTOMATEDREASONINGRULE_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &GUARDRAILAUTOMATEDREASONINGRULE_MEMBER_IDENTIFIER,
   52     52   
        &GUARDRAILAUTOMATEDREASONINGRULE_MEMBER_POLICY_VERSION_ARN,
   53     53   
    ],
   54     54   
);
   55     55   
impl GuardrailAutomatedReasoningRule {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILAUTOMATEDREASONINGRULE_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailAutomatedReasoningRule {
   60     60   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   61     61   
    fn serialize_members(
   62     62   
        &self,
   63     63   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   64     64   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        if let Some(ref val) = self.identifier {
   66     66   
            ser.write_string(&GUARDRAILAUTOMATEDREASONINGRULE_MEMBER_IDENTIFIER, val)?;
   67     67   
        }
   68     68   
        if let Some(ref val) = self.policy_version_arn {
   69     69   
            ser.write_string(&GUARDRAILAUTOMATEDREASONINGRULE_MEMBER_POLICY_VERSION_ARN, val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl GuardrailAutomatedReasoningRule {
   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(&GUARDRAILAUTOMATEDREASONINGRULE_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGRULE_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.identifier = Some(deser.read_string(member)?);
   92     92   
                }
   93     93   
                Some(1) => {
   94     94   
                    builder.policy_version_arn = Some(deser.read_string(member)?);
   95     95   
                }
   96     96   
                _ => {}
   97     97   
            }
   98     98   
            Ok(())
   99     99   
        })?;
  100    100   
        Ok(builder.build())
  101    101   
    }
  102    102   
}
         103  +
impl GuardrailAutomatedReasoningRule {
         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 GuardrailAutomatedReasoningRule {
  104    115   
    /// Creates a new builder-style object to manufacture [`GuardrailAutomatedReasoningRule`](crate::types::GuardrailAutomatedReasoningRule).
  105    116   
    pub fn builder() -> crate::types::builders::GuardrailAutomatedReasoningRuleBuilder {
  106    117   
        crate::types::builders::GuardrailAutomatedReasoningRuleBuilder::default()
  107    118   
    }
  108    119   
}
  109    120   
  110    121   
/// A builder for [`GuardrailAutomatedReasoningRule`](crate::types::GuardrailAutomatedReasoningRule).
  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_automated_reasoning_satisfiable_finding.rs

@@ -27,27 +180,191 @@
   47     47   
    0,
   48     48   
);
   49     49   
static GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_CLAIMS_TRUE_SCENARIO: ::aws_smithy_schema::Schema =
   50     50   
    ::aws_smithy_schema::Schema::new_member(
   51     51   
        ::aws_smithy_schema::ShapeId::from_static(
   52     52   
            "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningSatisfiableFinding$claimsTrueScenario",
   53     53   
            "com.amazonaws.bedrockruntime",
   54     54   
            "GuardrailAutomatedReasoningSatisfiableFinding",
   55     55   
        ),
   56     56   
        ::aws_smithy_schema::ShapeType::Structure,
   57         -
        "claims_true_scenario",
          57  +
        "claimsTrueScenario",
   58     58   
        1,
   59     59   
    );
   60     60   
static GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_CLAIMS_FALSE_SCENARIO: ::aws_smithy_schema::Schema =
   61     61   
    ::aws_smithy_schema::Schema::new_member(
   62     62   
        ::aws_smithy_schema::ShapeId::from_static(
   63     63   
            "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningSatisfiableFinding$claimsFalseScenario",
   64     64   
            "com.amazonaws.bedrockruntime",
   65     65   
            "GuardrailAutomatedReasoningSatisfiableFinding",
   66     66   
        ),
   67     67   
        ::aws_smithy_schema::ShapeType::Structure,
   68         -
        "claims_false_scenario",
          68  +
        "claimsFalseScenario",
   69     69   
        2,
   70     70   
    );
   71     71   
static GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_LOGIC_WARNING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.bedrockruntime#GuardrailAutomatedReasoningSatisfiableFinding$logicWarning",
   74     74   
        "com.amazonaws.bedrockruntime",
   75     75   
        "GuardrailAutomatedReasoningSatisfiableFinding",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::Structure,
   78         -
    "logic_warning",
          78  +
    "logicWarning",
   79     79   
    3,
   80     80   
);
   81     81   
static GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   82     82   
    GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_SCHEMA_ID,
   83     83   
    ::aws_smithy_schema::ShapeType::Structure,
   84     84   
    &[
   85     85   
        &GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_TRANSLATION,
   86     86   
        &GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_CLAIMS_TRUE_SCENARIO,
   87     87   
        &GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_CLAIMS_FALSE_SCENARIO,
   88     88   
        &GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_LOGIC_WARNING,
   89     89   
    ],
   90     90   
);
   91     91   
impl GuardrailAutomatedReasoningSatisfiableFinding {
   92     92   
    /// The schema for this shape.
   93     93   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_SCHEMA;
   94     94   
}
   95     95   
impl ::aws_smithy_schema::serde::SerializableStruct for GuardrailAutomatedReasoningSatisfiableFinding {
   96     96   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   97     97   
    fn serialize_members(
   98     98   
        &self,
   99     99   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  100    100   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  101    101   
        if let Some(ref val) = self.translation {
  102    102   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_TRANSLATION, val)?;
  103    103   
        }
  104    104   
        if let Some(ref val) = self.claims_true_scenario {
  105    105   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_CLAIMS_TRUE_SCENARIO, val)?;
  106    106   
        }
  107    107   
        if let Some(ref val) = self.claims_false_scenario {
  108    108   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_CLAIMS_FALSE_SCENARIO, val)?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.logic_warning {
  111    111   
            ser.write_struct(&GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_MEMBER_LOGIC_WARNING, val)?;
  112    112   
        }
  113    113   
        Ok(())
  114    114   
    }
  115    115   
}
  116    116   
impl GuardrailAutomatedReasoningSatisfiableFinding {
  117    117   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  118         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  119         -
        deserializer: &mut D,
         118  +
    pub fn deserialize(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  120    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        #[allow(unused_variables, unused_mut)]
  122    122   
        let mut builder = Self::builder();
  123    123   
        #[allow(
  124    124   
            unused_variables,
  125    125   
            unreachable_code,
  126    126   
            clippy::single_match,
  127    127   
            clippy::match_single_binding,
  128    128   
            clippy::diverging_sub_expression
  129    129   
        )]
  130         -
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_SCHEMA, (), |_, member, deser| {
         130  +
        deserializer.read_struct(&GUARDRAILAUTOMATEDREASONINGSATISFIABLEFINDING_SCHEMA, &mut |member, deser| {
  131    131   
            match member.member_index() {
  132    132   
                Some(0) => {
  133    133   
                    builder.translation = Some(crate::types::GuardrailAutomatedReasoningTranslation::deserialize(deser)?);
  134    134   
                }
  135    135   
                Some(1) => {
  136    136   
                    builder.claims_true_scenario = Some(crate::types::GuardrailAutomatedReasoningScenario::deserialize(deser)?);
  137    137   
                }
  138    138   
                Some(2) => {
  139    139   
                    builder.claims_false_scenario = Some(crate::types::GuardrailAutomatedReasoningScenario::deserialize(deser)?);
  140    140   
                }
  141    141   
                Some(3) => {
  142    142   
                    builder.logic_warning = Some(crate::types::GuardrailAutomatedReasoningLogicWarning::deserialize(deser)?);
  143    143   
                }
  144    144   
                _ => {}
  145    145   
            }
  146    146   
            Ok(())
  147    147   
        })?;
  148    148   
        Ok(builder.build())
  149    149   
    }
  150    150   
}
         151  +
impl GuardrailAutomatedReasoningSatisfiableFinding {
         152  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         153  +
    pub fn deserialize_with_response(
         154  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         155  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         156  +
        _status: u16,
         157  +
        _body: &[u8],
         158  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         159  +
        Self::deserialize(deserializer)
         160  +
    }
         161  +
}
  151    162   
impl GuardrailAutomatedReasoningSatisfiableFinding {
  152    163   
    /// Creates a new builder-style object to manufacture [`GuardrailAutomatedReasoningSatisfiableFinding`](crate::types::GuardrailAutomatedReasoningSatisfiableFinding).
  153    164   
    pub fn builder() -> crate::types::builders::GuardrailAutomatedReasoningSatisfiableFindingBuilder {
  154    165   
        crate::types::builders::GuardrailAutomatedReasoningSatisfiableFindingBuilder::default()
  155    166   
    }
  156    167   
}
  157    168   
  158    169   
/// A builder for [`GuardrailAutomatedReasoningSatisfiableFinding`](crate::types::GuardrailAutomatedReasoningSatisfiableFinding).
  159    170   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  160    171   
#[non_exhaustive]

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

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