Server Test Python

Server Test Python

rev. 7254d43655ed63111c94f599437f2b0d3f55446e

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/python/rest_json/socket/__init__.pyi

@@ -1,0 +27,0 @@
    1         -
import typing
    2         -
    3         -
class PySocket:
    4         -
    """
    5         -
    Socket implementation that can be shared between multiple Python processes.
    6         -
    7         -
    Python cannot handle true multi-threaded applications due to the [GIL],
    8         -
    often resulting in reduced performance and only one core used by the application.
    9         -
    To work around this, Python web applications usually create a socket with
   10         -
    SO_REUSEADDR and SO_REUSEPORT enabled that can be shared between multiple
   11         -
    Python processes, allowing you to maximize performance and use all available
   12         -
    computing capacity of the host.
   13         -
   14         -
    [GIL]: https://wiki.python.org/moin/GlobalInterpreterLock
   15         -
    """
   16         -
   17         -
    def try_clone(self) -> PySocket:
   18         -
        """
   19         -
        Clone the inner socket allowing it to be shared between multiple
   20         -
        Python processes.
   21         -
        """
   22         -
        ...
   23         -
   24         -
   25         -
    def __init__(self, address: str, port: int, backlog: typing.Optional[int] = ...) -> None:
   26         -
        ...
   27         -

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/python/rest_json/tls/__init__.pyi

@@ -1,0 +10,0 @@
    1         -
import pathlib
    2         -
    3         -
class TlsConfig:
    4         -
    """
    5         -
    PyTlsConfig represents TLS configuration created from Python.
    6         -
    """
    7         -
    8         -
    def __init__(self, key_path: pathlib.Path, cert_path: pathlib.Path, reload_secs: int = ...) -> None:
    9         -
        ...
   10         -

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/python/rest_json/types/__init__.pyi

@@ -1,0 +209,0 @@
    1         -
import typing
    2         -
    3         -
class Blob:
    4         -
    """
    5         -
    Python Wrapper for [aws_smithy_types::Blob].
    6         -
    """
    7         -
    8         -
    data: bytes
    9         -
    """
   10         -
    Python getter for the `Blob` byte array.
   11         -
    """
   12         -
   13         -
    def __init__(self, input: bytes) -> None:
   14         -
        ...
   15         -
   16         -
   17         -
class ByteStream:
   18         -
    """
   19         -
    Python Wrapper for [aws_smithy_types::byte_stream::ByteStream].
   20         -
   21         -
    ByteStream provides misuse-resistant primitives to make it easier to handle common patterns with streaming data.
   22         -
   23         -
    On the Rust side, The Python implementation wraps the original [ByteStream](aws_smithy_types::byte_stream::ByteStream)
   24         -
    in a clonable structure and implements the [Stream](futures::stream::Stream) trait for it to
   25         -
    allow Rust to handle the type transparently.
   26         -
   27         -
    On the Python side both sync and async iterators are exposed by implementing `__iter__()` and `__aiter__()` magic methods,
   28         -
    which allows to just loop over the stream chunks.
   29         -
   30         -
    ### Example of async streaming:
   31         -
   32         -
    ```python
   33         -
        stream = await ByteStream.from_path("/tmp/music.mp3")
   34         -
        async for chunk in stream:
   35         -
            print(chunk)
   36         -
    ```
   37         -
   38         -
    ### Example of sync streaming:
   39         -
   40         -
    ```python
   41         -
        stream = ByteStream.from_stream_blocking("/tmp/music.mp3")
   42         -
        for chunk in stream:
   43         -
            print(chunk)
   44         -
    ```
   45         -
   46         -
    The main difference between the two implementations is that the async one is scheduling the Python coroutines as Rust futures,
   47         -
    effectively maintaining the asyncronous behavior that Rust exposes, while the sync one is blocking the Tokio runtime to be able
   48         -
    to await one chunk at a time.
   49         -
   50         -
    The original Rust [ByteStream](aws_smithy_types::byte_stream::ByteStream) is wrapped inside a `Arc<Mutex>` to allow the type to be
   51         -
    [Clone] (required by PyO3) and to allow internal mutability, required to fetch the next chunk of data.
   52         -
    """
   53         -
   54         -
    @staticmethod
   55         -
    def from_path(path: str) -> typing.Awaitable[ByteStream]:
   56         -
        """
   57         -
        Create a new [ByteStream](aws_smithy_types::byte_stream::ByteStream) from a path, forcing
   58         -
        Python to await this coroutine.
   59         -
        """
   60         -
        ...
   61         -
   62         -
   63         -
    @staticmethod
   64         -
    def from_path_blocking(path: str) -> ByteStream:
   65         -
        """
   66         -
        Create a new [ByteStream](aws_smithy_types::byte_stream::ByteStream) from a path, without
   67         -
        requiring Python to await this method.
   68         -
   69         -
        **NOTE:** This method will block the Rust event loop when it is running.
   70         -
        """
   71         -
        ...
   72         -
   73         -
   74         -
    def __init__(self, input: bytes) -> None:
   75         -
        ...
   76         -
   77         -
   78         -
class DateTime:
   79         -
    """
   80         -
    Python Wrapper for [aws_smithy_types::date_time::DateTime].
   81         -
    """
   82         -
   83         -
    def as_nanos(self) -> int:
   84         -
        """
   85         -
        Returns the number of nanoseconds since the Unix epoch that this `DateTime` represents.
   86         -
        """
   87         -
        ...
   88         -
   89         -
   90         -
    def as_secs_f64(self) -> float:
   91         -
        """
   92         -
        Returns the `DateTime` value as an `f64` representing the seconds since the Unix epoch.
   93         -
        """
   94         -
        ...
   95         -
   96         -
   97         -
    @staticmethod
   98         -
    def from_fractional_secs(epoch_seconds: int, fraction: float) -> DateTime:
   99         -
        """
  100         -
        Creates a `DateTime` from a number of seconds and a fractional second since the Unix epoch.
  101         -
        """
  102         -
        ...
  103         -
  104         -
  105         -
    @staticmethod
  106         -
    def from_millis(epoch_millis: int) -> DateTime:
  107         -
        """
  108         -
        Creates a `DateTime` from a number of milliseconds since the Unix epoch.
  109         -
        """
  110         -
        ...
  111         -
  112         -
  113         -
    @staticmethod
  114         -
    def from_nanos(epoch_nanos: int) -> DateTime:
  115         -
        """
  116         -
        Creates a `DateTime` from a number of nanoseconds since the Unix epoch.
  117         -
        """
  118         -
        ...
  119         -
  120         -
  121         -
    @staticmethod
  122         -
    def from_secs(epoch_seconds: int) -> DateTime:
  123         -
        """
  124         -
        Creates a `DateTime` from a number of seconds since the Unix epoch.
  125         -
        """
  126         -
        ...
  127         -
  128         -
  129         -
    @staticmethod
  130         -
    def from_secs_and_nanos(seconds: int, subsecond_nanos: int) -> DateTime:
  131         -
        """
  132         -
        Creates a `DateTime` from a number of seconds and sub-second nanos since the Unix epoch.
  133         -
        """
  134         -
        ...
  135         -
  136         -
  137         -
    @staticmethod
  138         -
    def from_secs_f64(epoch_seconds: float) -> DateTime:
  139         -
        """
  140         -
        Creates a `DateTime` from an `f64` representing the number of seconds since the Unix epoch.
  141         -
        """
  142         -
        ...
  143         -
  144         -
  145         -
    @staticmethod
  146         -
    def from_str(s: str, format: Format) -> DateTime:
  147         -
        """
  148         -
        Parses a `DateTime` from a string using the given `format`.
  149         -
        """
  150         -
        ...
  151         -
  152         -
  153         -
    def has_subsec_nanos(self) -> bool:
  154         -
        """
  155         -
        Returns true if sub-second nanos is greater than zero.
  156         -
        """
  157         -
        ...
  158         -
  159         -
  160         -
    @staticmethod
  161         -
    def read(format: Format, delim: str) -> typing.Tuple[DateTime, str]:
  162         -
        """
  163         -
        Read 1 date of `format` from `s`, expecting either `delim` or EOF.
  164         -
  165         -
        TODO(PythonTyping): How do we represent `char` in Python?
  166         -
        """
  167         -
        ...
  168         -
  169         -
  170         -
    def secs(self) -> int:
  171         -
        """
  172         -
        Returns the epoch seconds component of the `DateTime`.
  173         -
        """
  174         -
        ...
  175         -
  176         -
  177         -
    def subsec_nanos(self) -> int:
  178         -
        """
  179         -
        Returns the sub-second nanos component of the `DateTime`.
  180         -
        """
  181         -
        ...
  182         -
  183         -
  184         -
    def to_millis(self) -> int:
  185         -
        """
  186         -
        Converts the `DateTime` to the number of milliseconds since the Unix epoch.
  187         -
        """
  188         -
        ...
  189         -
  190         -
  191         -
class Format:
  192         -
    """
  193         -
    Formats for representing a `DateTime` in the Smithy protocols.
  194         -
    """
  195         -
  196         -
    DateTime: Format
  197         -
    """
  198         -
    Formats for representing a `DateTime` in the Smithy protocols.
  199         -
    """
  200         -
  201         -
    EpochSeconds: Format
  202         -
    """
  203         -
    Formats for representing a `DateTime` in the Smithy protocols.
  204         -
    """
  205         -
  206         -
    HttpDate: Format
  207         -
    """
  208         -
    Formats for representing a `DateTime` in the Smithy protocols.
  209         -
    """

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/src/constrained.rs

@@ -1,1 +109,109 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3         -
pub(crate) mod sparse_set_map_constrained {
           3  +
pub(crate) mod foo_enum_list_constrained {
    4      4   
    5      5   
    #[derive(Debug, Clone)]
    6         -
    pub(crate) struct SparseSetMapConstrained(
    7         -
        pub(crate)  std::collections::HashMap<
    8         -
            ::std::string::String,
    9         -
            ::std::option::Option<crate::model::StringSet>,
   10         -
        >,
           6  +
    pub(crate) struct FooEnumListConstrained(pub(crate) std::vec::Vec<crate::model::FooEnum>);
           7  +
           8  +
    impl crate::constrained::Constrained for FooEnumListConstrained {
           9  +
        type Unconstrained =
          10  +
            crate::unconstrained::foo_enum_list_unconstrained::FooEnumListUnconstrained;
          11  +
    }
          12  +
    impl ::std::convert::From<FooEnumListConstrained> for ::std::vec::Vec<crate::model::FooEnum> {
          13  +
        fn from(v: FooEnumListConstrained) -> Self {
          14  +
            v.0
          15  +
        }
          16  +
    }
          17  +
}
          18  +
pub(crate) mod foo_enum_map_constrained {
          19  +
          20  +
    #[derive(Debug, Clone)]
          21  +
    pub(crate) struct FooEnumMapConstrained(
          22  +
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::FooEnum>,
   11     23   
    );
   12     24   
   13         -
    impl crate::constrained::Constrained for SparseSetMapConstrained {
          25  +
    impl crate::constrained::Constrained for FooEnumMapConstrained {
   14     26   
        type Unconstrained =
   15         -
            crate::unconstrained::sparse_set_map_unconstrained::SparseSetMapUnconstrained;
          27  +
            crate::unconstrained::foo_enum_map_unconstrained::FooEnumMapUnconstrained;
   16     28   
    }
   17         -
    impl ::std::convert::From<SparseSetMapConstrained>
   18         -
        for ::std::collections::HashMap<
   19         -
            ::std::string::String,
   20         -
            ::std::option::Option<::std::vec::Vec<::std::string::String>>,
   21         -
        >
          29  +
    impl ::std::convert::From<FooEnumMapConstrained>
          30  +
        for ::std::collections::HashMap<::std::string::String, crate::model::FooEnum>
   22     31   
    {
   23         -
        fn from(v: SparseSetMapConstrained) -> Self {
   24         -
            v.0.into_iter()
   25         -
                .map(|(k, v)| {
   26         -
                    let v = { v.map(|v| v.into()) };
   27         -
                    (k, v)
   28         -
                })
   29         -
                .collect()
          32  +
        fn from(v: FooEnumMapConstrained) -> Self {
          33  +
            v.0
   30     34   
        }
   31     35   
    }
   32     36   
}
   33     37   
pub(crate) mod dense_set_map_constrained {
   34     38   
   35     39   
    #[derive(Debug, Clone)]
   36     40   
    pub(crate) struct DenseSetMapConstrained(
   37     41   
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::StringSet>,
   38     42   
    );
   39     43   
   40     44   
    impl crate::constrained::Constrained for DenseSetMapConstrained {
   41     45   
        type Unconstrained =
   42     46   
            crate::unconstrained::dense_set_map_unconstrained::DenseSetMapUnconstrained;
   43     47   
    }
   44     48   
    impl ::std::convert::From<DenseSetMapConstrained>
   45     49   
        for ::std::collections::HashMap<
   46     50   
            ::std::string::String,
   47     51   
            ::std::vec::Vec<::std::string::String>,
   48     52   
        >
   49     53   
    {
   50     54   
        fn from(v: DenseSetMapConstrained) -> Self {
   51     55   
            v.0.into_iter()
   52     56   
                .map(|(k, v)| {
   53     57   
                    let v = { v.into() };
   54     58   
                    (k, v)
   55     59   
                })
   56     60   
                .collect()
   57     61   
        }
   58     62   
    }
   59     63   
}
   60         -
pub(crate) mod foo_enum_list_constrained {
   61         -
   62         -
    #[derive(Debug, Clone)]
   63         -
    pub(crate) struct FooEnumListConstrained(pub(crate) std::vec::Vec<crate::model::FooEnum>);
   64         -
   65         -
    impl crate::constrained::Constrained for FooEnumListConstrained {
   66         -
        type Unconstrained =
   67         -
            crate::unconstrained::foo_enum_list_unconstrained::FooEnumListUnconstrained;
   68         -
    }
   69         -
    impl ::std::convert::From<FooEnumListConstrained> for ::std::vec::Vec<crate::model::FooEnum> {
   70         -
        fn from(v: FooEnumListConstrained) -> Self {
   71         -
            v.0
   72         -
        }
   73         -
    }
   74         -
}
   75         -
pub(crate) mod foo_enum_map_constrained {
          64  +
pub(crate) mod sparse_set_map_constrained {
   76     65   
   77     66   
    #[derive(Debug, Clone)]
   78         -
    pub(crate) struct FooEnumMapConstrained(
   79         -
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::FooEnum>,
          67  +
    pub(crate) struct SparseSetMapConstrained(
          68  +
        pub(crate)  std::collections::HashMap<
          69  +
            ::std::string::String,
          70  +
            ::std::option::Option<crate::model::StringSet>,
          71  +
        >,
   80     72   
    );
   81     73   
   82         -
    impl crate::constrained::Constrained for FooEnumMapConstrained {
          74  +
    impl crate::constrained::Constrained for SparseSetMapConstrained {
   83     75   
        type Unconstrained =
   84         -
            crate::unconstrained::foo_enum_map_unconstrained::FooEnumMapUnconstrained;
          76  +
            crate::unconstrained::sparse_set_map_unconstrained::SparseSetMapUnconstrained;
   85     77   
    }
   86         -
    impl ::std::convert::From<FooEnumMapConstrained>
   87         -
        for ::std::collections::HashMap<::std::string::String, crate::model::FooEnum>
          78  +
    impl ::std::convert::From<SparseSetMapConstrained>
          79  +
        for ::std::collections::HashMap<
          80  +
            ::std::string::String,
          81  +
            ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          82  +
        >
   88     83   
    {
   89         -
        fn from(v: FooEnumMapConstrained) -> Self {
   90         -
            v.0
          84  +
        fn from(v: SparseSetMapConstrained) -> Self {
          85  +
            v.0.into_iter()
          86  +
                .map(|(k, v)| {
          87  +
                    let v = { v.map(|v| v.into()) };
          88  +
                    (k, v)
          89  +
                })
          90  +
                .collect()
   91     91   
        }
   92     92   
    }
   93     93   
}
   94     94   
   95     95   
/*
   96     96   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   97     97   
 * SPDX-License-Identifier: Apache-2.0
   98     98   
 */
   99     99   
  100    100   
pub(crate) trait Constrained {

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/src/error.rs

@@ -1,1 +3538,3330 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
/// Error type for the `OperationWithNestedStructure` operation.
    3         -
/// Each variant represents an error that can occur for the `OperationWithNestedStructure` operation.
           2  +
/// Error type for the `NoInputAndNoOutput` operation.
           3  +
/// Each variant represents an error that can occur for the `NoInputAndNoOutput` operation.
    4      4   
#[derive(::std::fmt::Debug)]
    5         -
pub enum OperationWithNestedStructureError {
    6         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
    7         -
    ValidationException(crate::error::ValidationException),
           5  +
pub enum NoInputAndNoOutputError {
    8      6   
    #[allow(missing_docs)] // documentation missing in model
    9      7   
    InternalServerError(crate::error::InternalServerError),
   10      8   
}
   11         -
impl ::std::fmt::Display for OperationWithNestedStructureError {
           9  +
impl ::std::fmt::Display for NoInputAndNoOutputError {
   12     10   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   13     11   
        match &self {
   14         -
            OperationWithNestedStructureError::ValidationException(_inner) => _inner.fmt(f),
   15         -
            OperationWithNestedStructureError::InternalServerError(_inner) => _inner.fmt(f),
          12  +
            NoInputAndNoOutputError::InternalServerError(_inner) => _inner.fmt(f),
   16     13   
        }
   17     14   
    }
   18     15   
}
   19         -
impl OperationWithNestedStructureError {
   20         -
    /// Returns `true` if the error kind is `OperationWithNestedStructureError::ValidationException`.
   21         -
    pub fn is_validation_exception(&self) -> bool {
   22         -
        matches!(
   23         -
            &self,
   24         -
            OperationWithNestedStructureError::ValidationException(_)
   25         -
        )
   26         -
    }
   27         -
    /// Returns `true` if the error kind is `OperationWithNestedStructureError::InternalServerError`.
          16  +
impl NoInputAndNoOutputError {
          17  +
    /// Returns `true` if the error kind is `NoInputAndNoOutputError::InternalServerError`.
   28     18   
    pub fn is_internal_server_error(&self) -> bool {
   29         -
        matches!(
   30         -
            &self,
   31         -
            OperationWithNestedStructureError::InternalServerError(_)
   32         -
        )
          19  +
        matches!(&self, NoInputAndNoOutputError::InternalServerError(_))
   33     20   
    }
   34     21   
    /// Returns the error name string by matching the correct variant.
   35     22   
    pub fn name(&self) -> &'static str {
   36     23   
        match &self {
   37         -
            OperationWithNestedStructureError::ValidationException(_inner) => _inner.name(),
   38         -
            OperationWithNestedStructureError::InternalServerError(_inner) => _inner.name(),
          24  +
            NoInputAndNoOutputError::InternalServerError(_inner) => _inner.name(),
   39     25   
        }
   40     26   
    }
   41     27   
}
   42         -
impl ::std::error::Error for OperationWithNestedStructureError {
          28  +
impl ::std::error::Error for NoInputAndNoOutputError {
   43     29   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
   44     30   
        match &self {
   45         -
            OperationWithNestedStructureError::ValidationException(_inner) => Some(_inner),
   46         -
            OperationWithNestedStructureError::InternalServerError(_inner) => Some(_inner),
          31  +
            NoInputAndNoOutputError::InternalServerError(_inner) => Some(_inner),
   47     32   
        }
   48     33   
    }
   49     34   
}
   50         -
impl ::std::convert::From<crate::error::ValidationException>
   51         -
    for crate::error::OperationWithNestedStructureError
   52         -
{
   53         -
    fn from(
   54         -
        variant: crate::error::ValidationException,
   55         -
    ) -> crate::error::OperationWithNestedStructureError {
   56         -
        Self::ValidationException(variant)
   57         -
    }
   58         -
}
   59     35   
impl ::std::convert::From<crate::error::InternalServerError>
   60         -
    for crate::error::OperationWithNestedStructureError
          36  +
    for crate::error::NoInputAndNoOutputError
   61     37   
{
   62         -
    fn from(
   63         -
        variant: crate::error::InternalServerError,
   64         -
    ) -> crate::error::OperationWithNestedStructureError {
          38  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::NoInputAndNoOutputError {
   65     39   
        Self::InternalServerError(variant)
   66     40   
    }
   67     41   
}
   68     42   
   69         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OperationWithNestedStructureError {
   70         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::OperationWithNestedStructureError {
          43  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NoInputAndNoOutputError {
          44  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::NoInputAndNoOutputError {
   71     45   
        ::pyo3::Python::with_gil(|py| {
   72     46   
            let error = variant.value(py);
   73         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
   74         -
                return error.into();
   75         -
            }
          47  +
   76     48   
            crate::error::InternalServerError {
   77     49   
                message: error.to_string(),
   78     50   
            }
   79     51   
            .into()
   80     52   
        })
   81     53   
    }
   82     54   
}
   83     55   
   84         -
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
   85         -
/// :param message str:
   86         -
/// :rtype None:
   87         -
#[allow(missing_docs)] // documentation missing in model
   88         -
#[derive(
   89         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
   90         -
)]
   91         -
pub struct InternalServerError {
   92         -
    #[pyo3(get, set)]
   93         -
    /// :type str:
   94         -
    #[allow(missing_docs)] // documentation missing in model
   95         -
    pub message: ::std::string::String,
   96         -
}
   97         -
#[allow(clippy::new_without_default)]
   98         -
#[allow(clippy::too_many_arguments)]
   99         -
#[::pyo3::pymethods]
  100         -
impl InternalServerError {
  101         -
    #[new]
  102         -
    pub fn new(message: ::std::string::String) -> Self {
  103         -
        Self { message }
  104         -
    }
  105         -
    fn __repr__(&self) -> String {
  106         -
        format!("{self:?}")
  107         -
    }
  108         -
    fn __str__(&self) -> String {
  109         -
        format!("{self:?}")
  110         -
    }
  111         -
}
  112         -
impl InternalServerError {
  113         -
    /// Returns the error message.
  114         -
    pub fn message(&self) -> &str {
  115         -
        &self.message
  116         -
    }
  117         -
    #[doc(hidden)]
  118         -
    /// Returns the error name.
  119         -
    pub fn name(&self) -> &'static str {
  120         -
        "InternalServerError"
  121         -
    }
  122         -
}
  123         -
impl ::std::fmt::Display for InternalServerError {
  124         -
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  125         -
        ::std::write!(f, "InternalServerError")?;
  126         -
        {
  127         -
            ::std::write!(f, ": {}", &self.message)?;
  128         -
        }
  129         -
        Ok(())
  130         -
    }
  131         -
}
  132         -
impl ::std::error::Error for InternalServerError {}
  133         -
impl InternalServerError {
  134         -
    /// Creates a new builder-style object to manufacture [`InternalServerError`](crate::error::InternalServerError).
  135         -
    pub fn builder() -> crate::error::internal_server_error::Builder {
  136         -
        crate::error::internal_server_error::Builder::default()
  137         -
    }
  138         -
}
  139         -
  140         -
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
  141         -
/// :param message str:
  142         -
/// :param field_list typing.Optional\[typing.List\[rest_json.model.ValidationExceptionField\]\]:
  143         -
/// :rtype None:
  144         -
/// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
  145         -
#[derive(
  146         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  147         -
)]
  148         -
pub struct ValidationException {
  149         -
    #[pyo3(get, set)]
  150         -
    /// :type str:
  151         -
    /// A summary of the validation failure.
  152         -
    pub message: ::std::string::String,
  153         -
    #[pyo3(get, set)]
  154         -
    /// :type typing.Optional\[typing.List\[rest_json.model.ValidationExceptionField\]\]:
  155         -
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
  156         -
    pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
  157         -
}
  158         -
impl ValidationException {
  159         -
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
  160         -
    pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
  161         -
        self.field_list.as_deref()
  162         -
    }
  163         -
}
  164         -
#[allow(clippy::new_without_default)]
  165         -
#[allow(clippy::too_many_arguments)]
  166         -
#[::pyo3::pymethods]
  167         -
impl ValidationException {
  168         -
    #[new]
  169         -
    pub fn new(
  170         -
        message: ::std::string::String,
  171         -
        field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
  172         -
    ) -> Self {
  173         -
        Self {
  174         -
            message,
  175         -
            field_list,
  176         -
        }
  177         -
    }
  178         -
    fn __repr__(&self) -> String {
  179         -
        format!("{self:?}")
  180         -
    }
  181         -
    fn __str__(&self) -> String {
  182         -
        format!("{self:?}")
  183         -
    }
  184         -
}
  185         -
impl ValidationException {
  186         -
    /// Returns the error message.
  187         -
    pub fn message(&self) -> &str {
  188         -
        &self.message
  189         -
    }
  190         -
    #[doc(hidden)]
  191         -
    /// Returns the error name.
  192         -
    pub fn name(&self) -> &'static str {
  193         -
        "ValidationException"
  194         -
    }
  195         -
}
  196         -
impl ::std::fmt::Display for ValidationException {
  197         -
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  198         -
        ::std::write!(f, "ValidationException")?;
  199         -
        {
  200         -
            ::std::write!(f, ": {}", &self.message)?;
  201         -
        }
  202         -
        Ok(())
  203         -
    }
  204         -
}
  205         -
impl ::std::error::Error for ValidationException {}
  206         -
impl ValidationException {
  207         -
    /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
  208         -
    pub fn builder() -> crate::error::validation_exception::Builder {
  209         -
        crate::error::validation_exception::Builder::default()
  210         -
    }
  211         -
}
  212         -
  213         -
/// Error type for the `OperationWithDefaults` operation.
  214         -
/// Each variant represents an error that can occur for the `OperationWithDefaults` operation.
          56  +
/// Error type for the `NoInputAndOutput` operation.
          57  +
/// Each variant represents an error that can occur for the `NoInputAndOutput` operation.
  215     58   
#[derive(::std::fmt::Debug)]
  216         -
pub enum OperationWithDefaultsError {
  217         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
  218         -
    ValidationException(crate::error::ValidationException),
          59  +
pub enum NoInputAndOutputError {
  219     60   
    #[allow(missing_docs)] // documentation missing in model
  220     61   
    InternalServerError(crate::error::InternalServerError),
  221     62   
}
  222         -
impl ::std::fmt::Display for OperationWithDefaultsError {
          63  +
impl ::std::fmt::Display for NoInputAndOutputError {
  223     64   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  224     65   
        match &self {
  225         -
            OperationWithDefaultsError::ValidationException(_inner) => _inner.fmt(f),
  226         -
            OperationWithDefaultsError::InternalServerError(_inner) => _inner.fmt(f),
          66  +
            NoInputAndOutputError::InternalServerError(_inner) => _inner.fmt(f),
  227     67   
        }
  228     68   
    }
  229     69   
}
  230         -
impl OperationWithDefaultsError {
  231         -
    /// Returns `true` if the error kind is `OperationWithDefaultsError::ValidationException`.
  232         -
    pub fn is_validation_exception(&self) -> bool {
  233         -
        matches!(&self, OperationWithDefaultsError::ValidationException(_))
  234         -
    }
  235         -
    /// Returns `true` if the error kind is `OperationWithDefaultsError::InternalServerError`.
          70  +
impl NoInputAndOutputError {
          71  +
    /// Returns `true` if the error kind is `NoInputAndOutputError::InternalServerError`.
  236     72   
    pub fn is_internal_server_error(&self) -> bool {
  237         -
        matches!(&self, OperationWithDefaultsError::InternalServerError(_))
          73  +
        matches!(&self, NoInputAndOutputError::InternalServerError(_))
  238     74   
    }
  239     75   
    /// Returns the error name string by matching the correct variant.
  240     76   
    pub fn name(&self) -> &'static str {
  241     77   
        match &self {
  242         -
            OperationWithDefaultsError::ValidationException(_inner) => _inner.name(),
  243         -
            OperationWithDefaultsError::InternalServerError(_inner) => _inner.name(),
          78  +
            NoInputAndOutputError::InternalServerError(_inner) => _inner.name(),
  244     79   
        }
  245     80   
    }
  246     81   
}
  247         -
impl ::std::error::Error for OperationWithDefaultsError {
          82  +
impl ::std::error::Error for NoInputAndOutputError {
  248     83   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  249     84   
        match &self {
  250         -
            OperationWithDefaultsError::ValidationException(_inner) => Some(_inner),
  251         -
            OperationWithDefaultsError::InternalServerError(_inner) => Some(_inner),
          85  +
            NoInputAndOutputError::InternalServerError(_inner) => Some(_inner),
  252     86   
        }
  253     87   
    }
  254     88   
}
  255         -
impl ::std::convert::From<crate::error::ValidationException>
  256         -
    for crate::error::OperationWithDefaultsError
  257         -
{
  258         -
    fn from(
  259         -
        variant: crate::error::ValidationException,
  260         -
    ) -> crate::error::OperationWithDefaultsError {
  261         -
        Self::ValidationException(variant)
  262         -
    }
  263         -
}
  264     89   
impl ::std::convert::From<crate::error::InternalServerError>
  265         -
    for crate::error::OperationWithDefaultsError
          90  +
    for crate::error::NoInputAndOutputError
  266     91   
{
  267         -
    fn from(
  268         -
        variant: crate::error::InternalServerError,
  269         -
    ) -> crate::error::OperationWithDefaultsError {
          92  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::NoInputAndOutputError {
  270     93   
        Self::InternalServerError(variant)
  271     94   
    }
  272     95   
}
  273     96   
  274         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OperationWithDefaultsError {
  275         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::OperationWithDefaultsError {
          97  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NoInputAndOutputError {
          98  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::NoInputAndOutputError {
  276     99   
        ::pyo3::Python::with_gil(|py| {
  277    100   
            let error = variant.value(py);
  278         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
  279         -
                return error.into();
  280         -
            }
         101  +
  281    102   
            crate::error::InternalServerError {
  282    103   
                message: error.to_string(),
  283    104   
            }
  284    105   
            .into()
  285    106   
        })
  286    107   
    }
  287    108   
}
  288    109   
  289         -
/// Error type for the `ContentTypeParameters` operation.
  290         -
/// Each variant represents an error that can occur for the `ContentTypeParameters` operation.
         110  +
/// Error type for the `EmptyInputAndEmptyOutput` operation.
         111  +
/// Each variant represents an error that can occur for the `EmptyInputAndEmptyOutput` operation.
  291    112   
#[derive(::std::fmt::Debug)]
  292         -
pub enum ContentTypeParametersError {
         113  +
pub enum EmptyInputAndEmptyOutputError {
  293    114   
    #[allow(missing_docs)] // documentation missing in model
  294    115   
    InternalServerError(crate::error::InternalServerError),
  295    116   
}
  296         -
impl ::std::fmt::Display for ContentTypeParametersError {
         117  +
impl ::std::fmt::Display for EmptyInputAndEmptyOutputError {
  297    118   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  298    119   
        match &self {
  299         -
            ContentTypeParametersError::InternalServerError(_inner) => _inner.fmt(f),
         120  +
            EmptyInputAndEmptyOutputError::InternalServerError(_inner) => _inner.fmt(f),
  300    121   
        }
  301    122   
    }
  302    123   
}
  303         -
impl ContentTypeParametersError {
  304         -
    /// Returns `true` if the error kind is `ContentTypeParametersError::InternalServerError`.
  305         -
    pub fn is_internal_server_error(&self) -> bool {
  306         -
        matches!(&self, ContentTypeParametersError::InternalServerError(_))
         124  +
impl EmptyInputAndEmptyOutputError {
         125  +
    /// Returns `true` if the error kind is `EmptyInputAndEmptyOutputError::InternalServerError`.
         126  +
    pub fn is_internal_server_error(&self) -> bool {
         127  +
        matches!(&self, EmptyInputAndEmptyOutputError::InternalServerError(_))
  307    128   
    }
  308    129   
    /// Returns the error name string by matching the correct variant.
  309    130   
    pub fn name(&self) -> &'static str {
  310    131   
        match &self {
  311         -
            ContentTypeParametersError::InternalServerError(_inner) => _inner.name(),
         132  +
            EmptyInputAndEmptyOutputError::InternalServerError(_inner) => _inner.name(),
  312    133   
        }
  313    134   
    }
  314    135   
}
  315         -
impl ::std::error::Error for ContentTypeParametersError {
         136  +
impl ::std::error::Error for EmptyInputAndEmptyOutputError {
  316    137   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  317    138   
        match &self {
  318         -
            ContentTypeParametersError::InternalServerError(_inner) => Some(_inner),
         139  +
            EmptyInputAndEmptyOutputError::InternalServerError(_inner) => Some(_inner),
  319    140   
        }
  320    141   
    }
  321    142   
}
  322    143   
impl ::std::convert::From<crate::error::InternalServerError>
  323         -
    for crate::error::ContentTypeParametersError
         144  +
    for crate::error::EmptyInputAndEmptyOutputError
  324    145   
{
  325    146   
    fn from(
  326    147   
        variant: crate::error::InternalServerError,
  327         -
    ) -> crate::error::ContentTypeParametersError {
         148  +
    ) -> crate::error::EmptyInputAndEmptyOutputError {
  328    149   
        Self::InternalServerError(variant)
  329    150   
    }
  330    151   
}
  331    152   
  332         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ContentTypeParametersError {
  333         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::ContentTypeParametersError {
         153  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::EmptyInputAndEmptyOutputError {
         154  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::EmptyInputAndEmptyOutputError {
  334    155   
        ::pyo3::Python::with_gil(|py| {
  335    156   
            let error = variant.value(py);
  336    157   
  337    158   
            crate::error::InternalServerError {
  338    159   
                message: error.to_string(),
  339    160   
            }
  340    161   
            .into()
  341    162   
        })
  342    163   
    }
  343    164   
}
  344    165   
  345         -
/// Error type for the `PutWithContentEncoding` operation.
  346         -
/// Each variant represents an error that can occur for the `PutWithContentEncoding` operation.
         166  +
/// Error type for the `UnitInputAndOutput` operation.
         167  +
/// Each variant represents an error that can occur for the `UnitInputAndOutput` operation.
  347    168   
#[derive(::std::fmt::Debug)]
  348         -
pub enum PutWithContentEncodingError {
         169  +
pub enum UnitInputAndOutputError {
  349    170   
    #[allow(missing_docs)] // documentation missing in model
  350    171   
    InternalServerError(crate::error::InternalServerError),
  351    172   
}
  352         -
impl ::std::fmt::Display for PutWithContentEncodingError {
         173  +
impl ::std::fmt::Display for UnitInputAndOutputError {
  353    174   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  354    175   
        match &self {
  355         -
            PutWithContentEncodingError::InternalServerError(_inner) => _inner.fmt(f),
         176  +
            UnitInputAndOutputError::InternalServerError(_inner) => _inner.fmt(f),
  356    177   
        }
  357    178   
    }
  358    179   
}
  359         -
impl PutWithContentEncodingError {
  360         -
    /// Returns `true` if the error kind is `PutWithContentEncodingError::InternalServerError`.
         180  +
impl UnitInputAndOutputError {
         181  +
    /// Returns `true` if the error kind is `UnitInputAndOutputError::InternalServerError`.
  361    182   
    pub fn is_internal_server_error(&self) -> bool {
  362         -
        matches!(&self, PutWithContentEncodingError::InternalServerError(_))
         183  +
        matches!(&self, UnitInputAndOutputError::InternalServerError(_))
  363    184   
    }
  364    185   
    /// Returns the error name string by matching the correct variant.
  365    186   
    pub fn name(&self) -> &'static str {
  366    187   
        match &self {
  367         -
            PutWithContentEncodingError::InternalServerError(_inner) => _inner.name(),
         188  +
            UnitInputAndOutputError::InternalServerError(_inner) => _inner.name(),
  368    189   
        }
  369    190   
    }
  370    191   
}
  371         -
impl ::std::error::Error for PutWithContentEncodingError {
         192  +
impl ::std::error::Error for UnitInputAndOutputError {
  372    193   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  373    194   
        match &self {
  374         -
            PutWithContentEncodingError::InternalServerError(_inner) => Some(_inner),
         195  +
            UnitInputAndOutputError::InternalServerError(_inner) => Some(_inner),
  375    196   
        }
  376    197   
    }
  377    198   
}
  378    199   
impl ::std::convert::From<crate::error::InternalServerError>
  379         -
    for crate::error::PutWithContentEncodingError
         200  +
    for crate::error::UnitInputAndOutputError
  380    201   
{
  381         -
    fn from(
  382         -
        variant: crate::error::InternalServerError,
  383         -
    ) -> crate::error::PutWithContentEncodingError {
         202  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::UnitInputAndOutputError {
  384    203   
        Self::InternalServerError(variant)
  385    204   
    }
  386    205   
}
  387    206   
  388         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::PutWithContentEncodingError {
  389         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::PutWithContentEncodingError {
         207  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::UnitInputAndOutputError {
         208  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::UnitInputAndOutputError {
  390    209   
        ::pyo3::Python::with_gil(|py| {
  391    210   
            let error = variant.value(py);
  392    211   
  393    212   
            crate::error::InternalServerError {
  394    213   
                message: error.to_string(),
  395    214   
            }
  396    215   
            .into()
  397    216   
        })
  398    217   
    }
  399    218   
}
  400    219   
  401         -
/// Error type for the `FractionalSeconds` operation.
  402         -
/// Each variant represents an error that can occur for the `FractionalSeconds` operation.
         220  +
/// Error type for the `InputAndOutputWithHeaders` operation.
         221  +
/// Each variant represents an error that can occur for the `InputAndOutputWithHeaders` operation.
  403    222   
#[derive(::std::fmt::Debug)]
  404         -
pub enum FractionalSecondsError {
         223  +
pub enum InputAndOutputWithHeadersError {
         224  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         225  +
    ValidationException(crate::error::ValidationException),
  405    226   
    #[allow(missing_docs)] // documentation missing in model
  406    227   
    InternalServerError(crate::error::InternalServerError),
  407    228   
}
  408         -
impl ::std::fmt::Display for FractionalSecondsError {
         229  +
impl ::std::fmt::Display for InputAndOutputWithHeadersError {
  409    230   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  410    231   
        match &self {
  411         -
            FractionalSecondsError::InternalServerError(_inner) => _inner.fmt(f),
         232  +
            InputAndOutputWithHeadersError::ValidationException(_inner) => _inner.fmt(f),
         233  +
            InputAndOutputWithHeadersError::InternalServerError(_inner) => _inner.fmt(f),
  412    234   
        }
  413    235   
    }
  414    236   
}
  415         -
impl FractionalSecondsError {
  416         -
    /// Returns `true` if the error kind is `FractionalSecondsError::InternalServerError`.
         237  +
impl InputAndOutputWithHeadersError {
         238  +
    /// Returns `true` if the error kind is `InputAndOutputWithHeadersError::ValidationException`.
         239  +
    pub fn is_validation_exception(&self) -> bool {
         240  +
        matches!(
         241  +
            &self,
         242  +
            InputAndOutputWithHeadersError::ValidationException(_)
         243  +
        )
         244  +
    }
         245  +
    /// Returns `true` if the error kind is `InputAndOutputWithHeadersError::InternalServerError`.
  417    246   
    pub fn is_internal_server_error(&self) -> bool {
  418         -
        matches!(&self, FractionalSecondsError::InternalServerError(_))
         247  +
        matches!(
         248  +
            &self,
         249  +
            InputAndOutputWithHeadersError::InternalServerError(_)
         250  +
        )
  419    251   
    }
  420    252   
    /// Returns the error name string by matching the correct variant.
  421    253   
    pub fn name(&self) -> &'static str {
  422    254   
        match &self {
  423         -
            FractionalSecondsError::InternalServerError(_inner) => _inner.name(),
         255  +
            InputAndOutputWithHeadersError::ValidationException(_inner) => _inner.name(),
         256  +
            InputAndOutputWithHeadersError::InternalServerError(_inner) => _inner.name(),
  424    257   
        }
  425    258   
    }
  426    259   
}
  427         -
impl ::std::error::Error for FractionalSecondsError {
         260  +
impl ::std::error::Error for InputAndOutputWithHeadersError {
  428    261   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  429    262   
        match &self {
  430         -
            FractionalSecondsError::InternalServerError(_inner) => Some(_inner),
         263  +
            InputAndOutputWithHeadersError::ValidationException(_inner) => Some(_inner),
         264  +
            InputAndOutputWithHeadersError::InternalServerError(_inner) => Some(_inner),
  431    265   
        }
  432    266   
    }
  433    267   
}
         268  +
impl ::std::convert::From<crate::error::ValidationException>
         269  +
    for crate::error::InputAndOutputWithHeadersError
         270  +
{
         271  +
    fn from(
         272  +
        variant: crate::error::ValidationException,
         273  +
    ) -> crate::error::InputAndOutputWithHeadersError {
         274  +
        Self::ValidationException(variant)
         275  +
    }
         276  +
}
  434    277   
impl ::std::convert::From<crate::error::InternalServerError>
  435         -
    for crate::error::FractionalSecondsError
         278  +
    for crate::error::InputAndOutputWithHeadersError
  436    279   
{
  437         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::FractionalSecondsError {
         280  +
    fn from(
         281  +
        variant: crate::error::InternalServerError,
         282  +
    ) -> crate::error::InputAndOutputWithHeadersError {
  438    283   
        Self::InternalServerError(variant)
  439    284   
    }
  440    285   
}
  441    286   
  442         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::FractionalSecondsError {
  443         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::FractionalSecondsError {
         287  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::InputAndOutputWithHeadersError {
         288  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::InputAndOutputWithHeadersError {
  444    289   
        ::pyo3::Python::with_gil(|py| {
  445    290   
            let error = variant.value(py);
  446         -
         291  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
         292  +
                return error.into();
         293  +
            }
  447    294   
            crate::error::InternalServerError {
  448    295   
                message: error.to_string(),
  449    296   
            }
  450    297   
            .into()
  451    298   
        })
  452    299   
    }
  453    300   
}
  454    301   
  455         -
/// Error type for the `DatetimeOffsets` operation.
  456         -
/// Each variant represents an error that can occur for the `DatetimeOffsets` operation.
         302  +
/// Error type for the `NullAndEmptyHeadersClient` operation.
         303  +
/// Each variant represents an error that can occur for the `NullAndEmptyHeadersClient` operation.
  457    304   
#[derive(::std::fmt::Debug)]
  458         -
pub enum DatetimeOffsetsError {
         305  +
pub enum NullAndEmptyHeadersClientError {
  459    306   
    #[allow(missing_docs)] // documentation missing in model
  460    307   
    InternalServerError(crate::error::InternalServerError),
  461    308   
}
  462         -
impl ::std::fmt::Display for DatetimeOffsetsError {
         309  +
impl ::std::fmt::Display for NullAndEmptyHeadersClientError {
  463    310   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  464    311   
        match &self {
  465         -
            DatetimeOffsetsError::InternalServerError(_inner) => _inner.fmt(f),
         312  +
            NullAndEmptyHeadersClientError::InternalServerError(_inner) => _inner.fmt(f),
  466    313   
        }
  467    314   
    }
  468    315   
}
  469         -
impl DatetimeOffsetsError {
  470         -
    /// Returns `true` if the error kind is `DatetimeOffsetsError::InternalServerError`.
         316  +
impl NullAndEmptyHeadersClientError {
         317  +
    /// Returns `true` if the error kind is `NullAndEmptyHeadersClientError::InternalServerError`.
  471    318   
    pub fn is_internal_server_error(&self) -> bool {
  472         -
        matches!(&self, DatetimeOffsetsError::InternalServerError(_))
         319  +
        matches!(
         320  +
            &self,
         321  +
            NullAndEmptyHeadersClientError::InternalServerError(_)
         322  +
        )
  473    323   
    }
  474    324   
    /// Returns the error name string by matching the correct variant.
  475    325   
    pub fn name(&self) -> &'static str {
  476    326   
        match &self {
  477         -
            DatetimeOffsetsError::InternalServerError(_inner) => _inner.name(),
         327  +
            NullAndEmptyHeadersClientError::InternalServerError(_inner) => _inner.name(),
  478    328   
        }
  479    329   
    }
  480    330   
}
  481         -
impl ::std::error::Error for DatetimeOffsetsError {
         331  +
impl ::std::error::Error for NullAndEmptyHeadersClientError {
  482    332   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  483    333   
        match &self {
  484         -
            DatetimeOffsetsError::InternalServerError(_inner) => Some(_inner),
         334  +
            NullAndEmptyHeadersClientError::InternalServerError(_inner) => Some(_inner),
  485    335   
        }
  486    336   
    }
  487    337   
}
  488    338   
impl ::std::convert::From<crate::error::InternalServerError>
  489         -
    for crate::error::DatetimeOffsetsError
         339  +
    for crate::error::NullAndEmptyHeadersClientError
  490    340   
{
  491         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::DatetimeOffsetsError {
         341  +
    fn from(
         342  +
        variant: crate::error::InternalServerError,
         343  +
    ) -> crate::error::NullAndEmptyHeadersClientError {
  492    344   
        Self::InternalServerError(variant)
  493    345   
    }
  494    346   
}
  495    347   
  496         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DatetimeOffsetsError {
  497         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::DatetimeOffsetsError {
         348  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NullAndEmptyHeadersClientError {
         349  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::NullAndEmptyHeadersClientError {
  498    350   
        ::pyo3::Python::with_gil(|py| {
  499    351   
            let error = variant.value(py);
  500    352   
  501    353   
            crate::error::InternalServerError {
  502    354   
                message: error.to_string(),
  503    355   
            }
  504    356   
            .into()
  505    357   
        })
  506    358   
    }
  507    359   
}
  508    360   
  509         -
/// Error type for the `TestPostNoInputNoPayload` operation.
  510         -
/// Each variant represents an error that can occur for the `TestPostNoInputNoPayload` operation.
         361  +
/// Error type for the `NullAndEmptyHeadersServer` operation.
         362  +
/// Each variant represents an error that can occur for the `NullAndEmptyHeadersServer` operation.
  511    363   
#[derive(::std::fmt::Debug)]
  512         -
pub enum TestPostNoInputNoPayloadError {
         364  +
pub enum NullAndEmptyHeadersServerError {
  513    365   
    #[allow(missing_docs)] // documentation missing in model
  514    366   
    InternalServerError(crate::error::InternalServerError),
  515    367   
}
  516         -
impl ::std::fmt::Display for TestPostNoInputNoPayloadError {
         368  +
impl ::std::fmt::Display for NullAndEmptyHeadersServerError {
  517    369   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  518    370   
        match &self {
  519         -
            TestPostNoInputNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
         371  +
            NullAndEmptyHeadersServerError::InternalServerError(_inner) => _inner.fmt(f),
  520    372   
        }
  521    373   
    }
  522    374   
}
  523         -
impl TestPostNoInputNoPayloadError {
  524         -
    /// Returns `true` if the error kind is `TestPostNoInputNoPayloadError::InternalServerError`.
         375  +
impl NullAndEmptyHeadersServerError {
         376  +
    /// Returns `true` if the error kind is `NullAndEmptyHeadersServerError::InternalServerError`.
  525    377   
    pub fn is_internal_server_error(&self) -> bool {
  526         -
        matches!(&self, TestPostNoInputNoPayloadError::InternalServerError(_))
         378  +
        matches!(
         379  +
            &self,
         380  +
            NullAndEmptyHeadersServerError::InternalServerError(_)
         381  +
        )
  527    382   
    }
  528    383   
    /// Returns the error name string by matching the correct variant.
  529    384   
    pub fn name(&self) -> &'static str {
  530    385   
        match &self {
  531         -
            TestPostNoInputNoPayloadError::InternalServerError(_inner) => _inner.name(),
         386  +
            NullAndEmptyHeadersServerError::InternalServerError(_inner) => _inner.name(),
  532    387   
        }
  533    388   
    }
  534    389   
}
  535         -
impl ::std::error::Error for TestPostNoInputNoPayloadError {
         390  +
impl ::std::error::Error for NullAndEmptyHeadersServerError {
  536    391   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  537    392   
        match &self {
  538         -
            TestPostNoInputNoPayloadError::InternalServerError(_inner) => Some(_inner),
         393  +
            NullAndEmptyHeadersServerError::InternalServerError(_inner) => Some(_inner),
  539    394   
        }
  540    395   
    }
  541    396   
}
  542    397   
impl ::std::convert::From<crate::error::InternalServerError>
  543         -
    for crate::error::TestPostNoInputNoPayloadError
         398  +
    for crate::error::NullAndEmptyHeadersServerError
  544    399   
{
  545    400   
    fn from(
  546    401   
        variant: crate::error::InternalServerError,
  547         -
    ) -> crate::error::TestPostNoInputNoPayloadError {
         402  +
    ) -> crate::error::NullAndEmptyHeadersServerError {
  548    403   
        Self::InternalServerError(variant)
  549    404   
    }
  550    405   
}
  551    406   
  552         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPostNoInputNoPayloadError {
  553         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPostNoInputNoPayloadError {
         407  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NullAndEmptyHeadersServerError {
         408  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::NullAndEmptyHeadersServerError {
  554    409   
        ::pyo3::Python::with_gil(|py| {
  555    410   
            let error = variant.value(py);
  556    411   
  557    412   
            crate::error::InternalServerError {
  558    413   
                message: error.to_string(),
  559    414   
            }
  560    415   
            .into()
  561    416   
        })
  562    417   
    }
  563    418   
}
  564    419   
  565         -
/// Error type for the `TestGetNoInputNoPayload` operation.
  566         -
/// Each variant represents an error that can occur for the `TestGetNoInputNoPayload` operation.
         420  +
/// Error type for the `TimestampFormatHeaders` operation.
         421  +
/// Each variant represents an error that can occur for the `TimestampFormatHeaders` operation.
  567    422   
#[derive(::std::fmt::Debug)]
  568         -
pub enum TestGetNoInputNoPayloadError {
         423  +
pub enum TimestampFormatHeadersError {
  569    424   
    #[allow(missing_docs)] // documentation missing in model
  570    425   
    InternalServerError(crate::error::InternalServerError),
  571    426   
}
  572         -
impl ::std::fmt::Display for TestGetNoInputNoPayloadError {
         427  +
impl ::std::fmt::Display for TimestampFormatHeadersError {
  573    428   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  574    429   
        match &self {
  575         -
            TestGetNoInputNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
         430  +
            TimestampFormatHeadersError::InternalServerError(_inner) => _inner.fmt(f),
  576    431   
        }
  577    432   
    }
  578    433   
}
  579         -
impl TestGetNoInputNoPayloadError {
  580         -
    /// Returns `true` if the error kind is `TestGetNoInputNoPayloadError::InternalServerError`.
         434  +
impl TimestampFormatHeadersError {
         435  +
    /// Returns `true` if the error kind is `TimestampFormatHeadersError::InternalServerError`.
  581    436   
    pub fn is_internal_server_error(&self) -> bool {
  582         -
        matches!(&self, TestGetNoInputNoPayloadError::InternalServerError(_))
         437  +
        matches!(&self, TimestampFormatHeadersError::InternalServerError(_))
  583    438   
    }
  584    439   
    /// Returns the error name string by matching the correct variant.
  585    440   
    pub fn name(&self) -> &'static str {
  586    441   
        match &self {
  587         -
            TestGetNoInputNoPayloadError::InternalServerError(_inner) => _inner.name(),
         442  +
            TimestampFormatHeadersError::InternalServerError(_inner) => _inner.name(),
  588    443   
        }
  589    444   
    }
  590    445   
}
  591         -
impl ::std::error::Error for TestGetNoInputNoPayloadError {
         446  +
impl ::std::error::Error for TimestampFormatHeadersError {
  592    447   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  593    448   
        match &self {
  594         -
            TestGetNoInputNoPayloadError::InternalServerError(_inner) => Some(_inner),
         449  +
            TimestampFormatHeadersError::InternalServerError(_inner) => Some(_inner),
  595    450   
        }
  596    451   
    }
  597    452   
}
  598    453   
impl ::std::convert::From<crate::error::InternalServerError>
  599         -
    for crate::error::TestGetNoInputNoPayloadError
         454  +
    for crate::error::TimestampFormatHeadersError
  600    455   
{
  601    456   
    fn from(
  602    457   
        variant: crate::error::InternalServerError,
  603         -
    ) -> crate::error::TestGetNoInputNoPayloadError {
         458  +
    ) -> crate::error::TimestampFormatHeadersError {
  604    459   
        Self::InternalServerError(variant)
  605    460   
    }
  606    461   
}
  607    462   
  608         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestGetNoInputNoPayloadError {
  609         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestGetNoInputNoPayloadError {
         463  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TimestampFormatHeadersError {
         464  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TimestampFormatHeadersError {
  610    465   
        ::pyo3::Python::with_gil(|py| {
  611    466   
            let error = variant.value(py);
  612    467   
  613    468   
            crate::error::InternalServerError {
  614    469   
                message: error.to_string(),
  615    470   
            }
  616    471   
            .into()
  617    472   
        })
  618    473   
    }
  619    474   
}
  620    475   
  621         -
/// Error type for the `TestPostNoPayload` operation.
  622         -
/// Each variant represents an error that can occur for the `TestPostNoPayload` operation.
         476  +
/// Error type for the `MediaTypeHeader` operation.
         477  +
/// Each variant represents an error that can occur for the `MediaTypeHeader` operation.
  623    478   
#[derive(::std::fmt::Debug)]
  624         -
pub enum TestPostNoPayloadError {
         479  +
pub enum MediaTypeHeaderError {
  625    480   
    #[allow(missing_docs)] // documentation missing in model
  626    481   
    InternalServerError(crate::error::InternalServerError),
  627    482   
}
  628         -
impl ::std::fmt::Display for TestPostNoPayloadError {
         483  +
impl ::std::fmt::Display for MediaTypeHeaderError {
  629    484   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  630    485   
        match &self {
  631         -
            TestPostNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
         486  +
            MediaTypeHeaderError::InternalServerError(_inner) => _inner.fmt(f),
  632    487   
        }
  633    488   
    }
  634    489   
}
  635         -
impl TestPostNoPayloadError {
  636         -
    /// Returns `true` if the error kind is `TestPostNoPayloadError::InternalServerError`.
         490  +
impl MediaTypeHeaderError {
         491  +
    /// Returns `true` if the error kind is `MediaTypeHeaderError::InternalServerError`.
  637    492   
    pub fn is_internal_server_error(&self) -> bool {
  638         -
        matches!(&self, TestPostNoPayloadError::InternalServerError(_))
         493  +
        matches!(&self, MediaTypeHeaderError::InternalServerError(_))
  639    494   
    }
  640    495   
    /// Returns the error name string by matching the correct variant.
  641    496   
    pub fn name(&self) -> &'static str {
  642    497   
        match &self {
  643         -
            TestPostNoPayloadError::InternalServerError(_inner) => _inner.name(),
         498  +
            MediaTypeHeaderError::InternalServerError(_inner) => _inner.name(),
  644    499   
        }
  645    500   
    }
  646    501   
}
  647         -
impl ::std::error::Error for TestPostNoPayloadError {
         502  +
impl ::std::error::Error for MediaTypeHeaderError {
  648    503   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  649    504   
        match &self {
  650         -
            TestPostNoPayloadError::InternalServerError(_inner) => Some(_inner),
         505  +
            MediaTypeHeaderError::InternalServerError(_inner) => Some(_inner),
  651    506   
        }
  652    507   
    }
  653    508   
}
  654    509   
impl ::std::convert::From<crate::error::InternalServerError>
  655         -
    for crate::error::TestPostNoPayloadError
         510  +
    for crate::error::MediaTypeHeaderError
  656    511   
{
  657         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestPostNoPayloadError {
         512  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MediaTypeHeaderError {
  658    513   
        Self::InternalServerError(variant)
  659    514   
    }
  660    515   
}
  661    516   
  662         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPostNoPayloadError {
  663         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPostNoPayloadError {
         517  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MediaTypeHeaderError {
         518  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MediaTypeHeaderError {
  664    519   
        ::pyo3::Python::with_gil(|py| {
  665    520   
            let error = variant.value(py);
  666    521   
  667    522   
            crate::error::InternalServerError {
  668    523   
                message: error.to_string(),
  669    524   
            }
  670    525   
            .into()
  671    526   
        })
  672    527   
    }
  673    528   
}
  674    529   
  675         -
/// Error type for the `TestGetNoPayload` operation.
  676         -
/// Each variant represents an error that can occur for the `TestGetNoPayload` operation.
         530  +
/// Error type for the `HttpRequestWithLabels` operation.
         531  +
/// Each variant represents an error that can occur for the `HttpRequestWithLabels` operation.
  677    532   
#[derive(::std::fmt::Debug)]
  678         -
pub enum TestGetNoPayloadError {
         533  +
pub enum HttpRequestWithLabelsError {
         534  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         535  +
    ValidationException(crate::error::ValidationException),
  679    536   
    #[allow(missing_docs)] // documentation missing in model
  680    537   
    InternalServerError(crate::error::InternalServerError),
  681    538   
}
  682         -
impl ::std::fmt::Display for TestGetNoPayloadError {
         539  +
impl ::std::fmt::Display for HttpRequestWithLabelsError {
  683    540   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  684    541   
        match &self {
  685         -
            TestGetNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
         542  +
            HttpRequestWithLabelsError::ValidationException(_inner) => _inner.fmt(f),
         543  +
            HttpRequestWithLabelsError::InternalServerError(_inner) => _inner.fmt(f),
  686    544   
        }
  687    545   
    }
  688    546   
}
  689         -
impl TestGetNoPayloadError {
  690         -
    /// Returns `true` if the error kind is `TestGetNoPayloadError::InternalServerError`.
  691         -
    pub fn is_internal_server_error(&self) -> bool {
  692         -
        matches!(&self, TestGetNoPayloadError::InternalServerError(_))
         547  +
impl HttpRequestWithLabelsError {
         548  +
    /// Returns `true` if the error kind is `HttpRequestWithLabelsError::ValidationException`.
         549  +
    pub fn is_validation_exception(&self) -> bool {
         550  +
        matches!(&self, HttpRequestWithLabelsError::ValidationException(_))
         551  +
    }
         552  +
    /// Returns `true` if the error kind is `HttpRequestWithLabelsError::InternalServerError`.
         553  +
    pub fn is_internal_server_error(&self) -> bool {
         554  +
        matches!(&self, HttpRequestWithLabelsError::InternalServerError(_))
  693    555   
    }
  694    556   
    /// Returns the error name string by matching the correct variant.
  695    557   
    pub fn name(&self) -> &'static str {
  696    558   
        match &self {
  697         -
            TestGetNoPayloadError::InternalServerError(_inner) => _inner.name(),
         559  +
            HttpRequestWithLabelsError::ValidationException(_inner) => _inner.name(),
         560  +
            HttpRequestWithLabelsError::InternalServerError(_inner) => _inner.name(),
  698    561   
        }
  699    562   
    }
  700    563   
}
  701         -
impl ::std::error::Error for TestGetNoPayloadError {
         564  +
impl ::std::error::Error for HttpRequestWithLabelsError {
  702    565   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  703    566   
        match &self {
  704         -
            TestGetNoPayloadError::InternalServerError(_inner) => Some(_inner),
         567  +
            HttpRequestWithLabelsError::ValidationException(_inner) => Some(_inner),
         568  +
            HttpRequestWithLabelsError::InternalServerError(_inner) => Some(_inner),
  705    569   
        }
  706    570   
    }
  707    571   
}
         572  +
impl ::std::convert::From<crate::error::ValidationException>
         573  +
    for crate::error::HttpRequestWithLabelsError
         574  +
{
         575  +
    fn from(
         576  +
        variant: crate::error::ValidationException,
         577  +
    ) -> crate::error::HttpRequestWithLabelsError {
         578  +
        Self::ValidationException(variant)
         579  +
    }
         580  +
}
  708    581   
impl ::std::convert::From<crate::error::InternalServerError>
  709         -
    for crate::error::TestGetNoPayloadError
         582  +
    for crate::error::HttpRequestWithLabelsError
  710    583   
{
  711         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestGetNoPayloadError {
         584  +
    fn from(
         585  +
        variant: crate::error::InternalServerError,
         586  +
    ) -> crate::error::HttpRequestWithLabelsError {
  712    587   
        Self::InternalServerError(variant)
  713    588   
    }
  714    589   
}
  715    590   
  716         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestGetNoPayloadError {
  717         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestGetNoPayloadError {
         591  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithLabelsError {
         592  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithLabelsError {
  718    593   
        ::pyo3::Python::with_gil(|py| {
  719    594   
            let error = variant.value(py);
  720         -
         595  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
         596  +
                return error.into();
         597  +
            }
  721    598   
            crate::error::InternalServerError {
  722    599   
                message: error.to_string(),
  723    600   
            }
  724    601   
            .into()
  725    602   
        })
  726    603   
    }
  727    604   
}
  728    605   
  729         -
/// Error type for the `TestPayloadBlob` operation.
  730         -
/// Each variant represents an error that can occur for the `TestPayloadBlob` operation.
         606  +
/// Error type for the `HttpRequestWithLabelsAndTimestampFormat` operation.
         607  +
/// Each variant represents an error that can occur for the `HttpRequestWithLabelsAndTimestampFormat` operation.
  731    608   
#[derive(::std::fmt::Debug)]
  732         -
pub enum TestPayloadBlobError {
         609  +
pub enum HttpRequestWithLabelsAndTimestampFormatError {
         610  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         611  +
    ValidationException(crate::error::ValidationException),
  733    612   
    #[allow(missing_docs)] // documentation missing in model
  734    613   
    InternalServerError(crate::error::InternalServerError),
  735    614   
}
  736         -
impl ::std::fmt::Display for TestPayloadBlobError {
         615  +
impl ::std::fmt::Display for HttpRequestWithLabelsAndTimestampFormatError {
  737    616   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  738    617   
        match &self {
  739         -
            TestPayloadBlobError::InternalServerError(_inner) => _inner.fmt(f),
         618  +
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_inner) => {
         619  +
                _inner.fmt(f)
         620  +
            }
         621  +
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_inner) => {
         622  +
                _inner.fmt(f)
         623  +
            }
  740    624   
        }
  741    625   
    }
  742    626   
}
  743         -
impl TestPayloadBlobError {
  744         -
    /// Returns `true` if the error kind is `TestPayloadBlobError::InternalServerError`.
         627  +
impl HttpRequestWithLabelsAndTimestampFormatError {
         628  +
    /// Returns `true` if the error kind is `HttpRequestWithLabelsAndTimestampFormatError::ValidationException`.
         629  +
    pub fn is_validation_exception(&self) -> bool {
         630  +
        matches!(
         631  +
            &self,
         632  +
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_)
         633  +
        )
         634  +
    }
         635  +
    /// Returns `true` if the error kind is `HttpRequestWithLabelsAndTimestampFormatError::InternalServerError`.
  745    636   
    pub fn is_internal_server_error(&self) -> bool {
  746         -
        matches!(&self, TestPayloadBlobError::InternalServerError(_))
         637  +
        matches!(
         638  +
            &self,
         639  +
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_)
         640  +
        )
  747    641   
    }
  748    642   
    /// Returns the error name string by matching the correct variant.
  749    643   
    pub fn name(&self) -> &'static str {
  750    644   
        match &self {
  751         -
            TestPayloadBlobError::InternalServerError(_inner) => _inner.name(),
         645  +
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_inner) => {
         646  +
                _inner.name()
         647  +
            }
         648  +
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_inner) => {
         649  +
                _inner.name()
         650  +
            }
  752    651   
        }
  753    652   
    }
  754    653   
}
  755         -
impl ::std::error::Error for TestPayloadBlobError {
         654  +
impl ::std::error::Error for HttpRequestWithLabelsAndTimestampFormatError {
  756    655   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  757    656   
        match &self {
  758         -
            TestPayloadBlobError::InternalServerError(_inner) => Some(_inner),
         657  +
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_inner) => {
         658  +
                Some(_inner)
         659  +
            }
         660  +
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_inner) => {
         661  +
                Some(_inner)
         662  +
            }
  759    663   
        }
  760    664   
    }
  761    665   
}
         666  +
impl ::std::convert::From<crate::error::ValidationException>
         667  +
    for crate::error::HttpRequestWithLabelsAndTimestampFormatError
         668  +
{
         669  +
    fn from(
         670  +
        variant: crate::error::ValidationException,
         671  +
    ) -> crate::error::HttpRequestWithLabelsAndTimestampFormatError {
         672  +
        Self::ValidationException(variant)
         673  +
    }
         674  +
}
  762    675   
impl ::std::convert::From<crate::error::InternalServerError>
  763         -
    for crate::error::TestPayloadBlobError
         676  +
    for crate::error::HttpRequestWithLabelsAndTimestampFormatError
  764    677   
{
  765         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestPayloadBlobError {
         678  +
    fn from(
         679  +
        variant: crate::error::InternalServerError,
         680  +
    ) -> crate::error::HttpRequestWithLabelsAndTimestampFormatError {
  766    681   
        Self::InternalServerError(variant)
  767    682   
    }
  768    683   
}
  769    684   
  770         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPayloadBlobError {
  771         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPayloadBlobError {
         685  +
impl ::std::convert::From<::pyo3::PyErr>
         686  +
    for crate::error::HttpRequestWithLabelsAndTimestampFormatError
         687  +
{
         688  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithLabelsAndTimestampFormatError {
  772    689   
        ::pyo3::Python::with_gil(|py| {
  773    690   
            let error = variant.value(py);
  774         -
         691  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
         692  +
                return error.into();
         693  +
            }
  775    694   
            crate::error::InternalServerError {
  776    695   
                message: error.to_string(),
  777    696   
            }
  778    697   
            .into()
  779    698   
        })
  780    699   
    }
  781    700   
}
  782    701   
  783         -
/// Error type for the `TestPayloadStructure` operation.
  784         -
/// Each variant represents an error that can occur for the `TestPayloadStructure` operation.
         702  +
/// Error type for the `HttpRequestWithGreedyLabelInPath` operation.
         703  +
/// Each variant represents an error that can occur for the `HttpRequestWithGreedyLabelInPath` operation.
  785    704   
#[derive(::std::fmt::Debug)]
  786         -
pub enum TestPayloadStructureError {
         705  +
pub enum HttpRequestWithGreedyLabelInPathError {
         706  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         707  +
    ValidationException(crate::error::ValidationException),
  787    708   
    #[allow(missing_docs)] // documentation missing in model
  788    709   
    InternalServerError(crate::error::InternalServerError),
  789    710   
}
  790         -
impl ::std::fmt::Display for TestPayloadStructureError {
         711  +
impl ::std::fmt::Display for HttpRequestWithGreedyLabelInPathError {
  791    712   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  792    713   
        match &self {
  793         -
            TestPayloadStructureError::InternalServerError(_inner) => _inner.fmt(f),
         714  +
            HttpRequestWithGreedyLabelInPathError::ValidationException(_inner) => _inner.fmt(f),
         715  +
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_inner) => _inner.fmt(f),
  794    716   
        }
  795    717   
    }
  796    718   
}
  797         -
impl TestPayloadStructureError {
  798         -
    /// Returns `true` if the error kind is `TestPayloadStructureError::InternalServerError`.
         719  +
impl HttpRequestWithGreedyLabelInPathError {
         720  +
    /// Returns `true` if the error kind is `HttpRequestWithGreedyLabelInPathError::ValidationException`.
         721  +
    pub fn is_validation_exception(&self) -> bool {
         722  +
        matches!(
         723  +
            &self,
         724  +
            HttpRequestWithGreedyLabelInPathError::ValidationException(_)
         725  +
        )
         726  +
    }
         727  +
    /// Returns `true` if the error kind is `HttpRequestWithGreedyLabelInPathError::InternalServerError`.
  799    728   
    pub fn is_internal_server_error(&self) -> bool {
  800         -
        matches!(&self, TestPayloadStructureError::InternalServerError(_))
         729  +
        matches!(
         730  +
            &self,
         731  +
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_)
         732  +
        )
  801    733   
    }
  802    734   
    /// Returns the error name string by matching the correct variant.
  803    735   
    pub fn name(&self) -> &'static str {
  804    736   
        match &self {
  805         -
            TestPayloadStructureError::InternalServerError(_inner) => _inner.name(),
         737  +
            HttpRequestWithGreedyLabelInPathError::ValidationException(_inner) => _inner.name(),
         738  +
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_inner) => _inner.name(),
  806    739   
        }
  807    740   
    }
  808    741   
}
  809         -
impl ::std::error::Error for TestPayloadStructureError {
         742  +
impl ::std::error::Error for HttpRequestWithGreedyLabelInPathError {
  810    743   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  811    744   
        match &self {
  812         -
            TestPayloadStructureError::InternalServerError(_inner) => Some(_inner),
         745  +
            HttpRequestWithGreedyLabelInPathError::ValidationException(_inner) => Some(_inner),
         746  +
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_inner) => Some(_inner),
  813    747   
        }
  814    748   
    }
  815    749   
}
         750  +
impl ::std::convert::From<crate::error::ValidationException>
         751  +
    for crate::error::HttpRequestWithGreedyLabelInPathError
         752  +
{
         753  +
    fn from(
         754  +
        variant: crate::error::ValidationException,
         755  +
    ) -> crate::error::HttpRequestWithGreedyLabelInPathError {
         756  +
        Self::ValidationException(variant)
         757  +
    }
         758  +
}
  816    759   
impl ::std::convert::From<crate::error::InternalServerError>
  817         -
    for crate::error::TestPayloadStructureError
         760  +
    for crate::error::HttpRequestWithGreedyLabelInPathError
  818    761   
{
  819         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestPayloadStructureError {
         762  +
    fn from(
         763  +
        variant: crate::error::InternalServerError,
         764  +
    ) -> crate::error::HttpRequestWithGreedyLabelInPathError {
  820    765   
        Self::InternalServerError(variant)
  821    766   
    }
  822    767   
}
  823    768   
  824         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPayloadStructureError {
  825         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPayloadStructureError {
         769  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithGreedyLabelInPathError {
         770  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithGreedyLabelInPathError {
  826    771   
        ::pyo3::Python::with_gil(|py| {
  827    772   
            let error = variant.value(py);
  828         -
         773  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
         774  +
                return error.into();
         775  +
            }
  829    776   
            crate::error::InternalServerError {
  830    777   
                message: error.to_string(),
  831    778   
            }
  832    779   
            .into()
  833    780   
        })
  834    781   
    }
  835    782   
}
  836    783   
  837         -
/// Error type for the `TestBodyStructure` operation.
  838         -
/// Each variant represents an error that can occur for the `TestBodyStructure` operation.
         784  +
/// Error type for the `HttpRequestWithFloatLabels` operation.
         785  +
/// Each variant represents an error that can occur for the `HttpRequestWithFloatLabels` operation.
  839    786   
#[derive(::std::fmt::Debug)]
  840         -
pub enum TestBodyStructureError {
         787  +
pub enum HttpRequestWithFloatLabelsError {
         788  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         789  +
    ValidationException(crate::error::ValidationException),
  841    790   
    #[allow(missing_docs)] // documentation missing in model
  842    791   
    InternalServerError(crate::error::InternalServerError),
  843    792   
}
  844         -
impl ::std::fmt::Display for TestBodyStructureError {
         793  +
impl ::std::fmt::Display for HttpRequestWithFloatLabelsError {
  845    794   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  846    795   
        match &self {
  847         -
            TestBodyStructureError::InternalServerError(_inner) => _inner.fmt(f),
         796  +
            HttpRequestWithFloatLabelsError::ValidationException(_inner) => _inner.fmt(f),
         797  +
            HttpRequestWithFloatLabelsError::InternalServerError(_inner) => _inner.fmt(f),
  848    798   
        }
  849    799   
    }
  850    800   
}
  851         -
impl TestBodyStructureError {
  852         -
    /// Returns `true` if the error kind is `TestBodyStructureError::InternalServerError`.
         801  +
impl HttpRequestWithFloatLabelsError {
         802  +
    /// Returns `true` if the error kind is `HttpRequestWithFloatLabelsError::ValidationException`.
         803  +
    pub fn is_validation_exception(&self) -> bool {
         804  +
        matches!(
         805  +
            &self,
         806  +
            HttpRequestWithFloatLabelsError::ValidationException(_)
         807  +
        )
         808  +
    }
         809  +
    /// Returns `true` if the error kind is `HttpRequestWithFloatLabelsError::InternalServerError`.
  853    810   
    pub fn is_internal_server_error(&self) -> bool {
  854         -
        matches!(&self, TestBodyStructureError::InternalServerError(_))
         811  +
        matches!(
         812  +
            &self,
         813  +
            HttpRequestWithFloatLabelsError::InternalServerError(_)
         814  +
        )
  855    815   
    }
  856    816   
    /// Returns the error name string by matching the correct variant.
  857    817   
    pub fn name(&self) -> &'static str {
  858    818   
        match &self {
  859         -
            TestBodyStructureError::InternalServerError(_inner) => _inner.name(),
         819  +
            HttpRequestWithFloatLabelsError::ValidationException(_inner) => _inner.name(),
         820  +
            HttpRequestWithFloatLabelsError::InternalServerError(_inner) => _inner.name(),
  860    821   
        }
  861    822   
    }
  862    823   
}
  863         -
impl ::std::error::Error for TestBodyStructureError {
         824  +
impl ::std::error::Error for HttpRequestWithFloatLabelsError {
  864    825   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  865    826   
        match &self {
  866         -
            TestBodyStructureError::InternalServerError(_inner) => Some(_inner),
         827  +
            HttpRequestWithFloatLabelsError::ValidationException(_inner) => Some(_inner),
         828  +
            HttpRequestWithFloatLabelsError::InternalServerError(_inner) => Some(_inner),
  867    829   
        }
  868    830   
    }
  869    831   
}
         832  +
impl ::std::convert::From<crate::error::ValidationException>
         833  +
    for crate::error::HttpRequestWithFloatLabelsError
         834  +
{
         835  +
    fn from(
         836  +
        variant: crate::error::ValidationException,
         837  +
    ) -> crate::error::HttpRequestWithFloatLabelsError {
         838  +
        Self::ValidationException(variant)
         839  +
    }
         840  +
}
  870    841   
impl ::std::convert::From<crate::error::InternalServerError>
  871         -
    for crate::error::TestBodyStructureError
         842  +
    for crate::error::HttpRequestWithFloatLabelsError
  872    843   
{
  873         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestBodyStructureError {
         844  +
    fn from(
         845  +
        variant: crate::error::InternalServerError,
         846  +
    ) -> crate::error::HttpRequestWithFloatLabelsError {
  874    847   
        Self::InternalServerError(variant)
  875    848   
    }
  876    849   
}
  877    850   
  878         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestBodyStructureError {
  879         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestBodyStructureError {
         851  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithFloatLabelsError {
         852  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithFloatLabelsError {
  880    853   
        ::pyo3::Python::with_gil(|py| {
  881    854   
            let error = variant.value(py);
  882         -
         855  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
         856  +
                return error.into();
         857  +
            }
  883    858   
            crate::error::InternalServerError {
  884    859   
                message: error.to_string(),
  885    860   
            }
  886    861   
            .into()
  887    862   
        })
  888    863   
    }
  889    864   
}
  890    865   
  891         -
/// Error type for the `MalformedAcceptWithGenericString` operation.
  892         -
/// Each variant represents an error that can occur for the `MalformedAcceptWithGenericString` operation.
         866  +
/// Error type for the `HttpRequestWithRegexLiteral` operation.
         867  +
/// Each variant represents an error that can occur for the `HttpRequestWithRegexLiteral` operation.
  893    868   
#[derive(::std::fmt::Debug)]
  894         -
pub enum MalformedAcceptWithGenericStringError {
         869  +
pub enum HttpRequestWithRegexLiteralError {
         870  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         871  +
    ValidationException(crate::error::ValidationException),
  895    872   
    #[allow(missing_docs)] // documentation missing in model
  896    873   
    InternalServerError(crate::error::InternalServerError),
  897    874   
}
  898         -
impl ::std::fmt::Display for MalformedAcceptWithGenericStringError {
         875  +
impl ::std::fmt::Display for HttpRequestWithRegexLiteralError {
  899    876   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  900    877   
        match &self {
  901         -
            MalformedAcceptWithGenericStringError::InternalServerError(_inner) => _inner.fmt(f),
         878  +
            HttpRequestWithRegexLiteralError::ValidationException(_inner) => _inner.fmt(f),
         879  +
            HttpRequestWithRegexLiteralError::InternalServerError(_inner) => _inner.fmt(f),
  902    880   
        }
  903    881   
    }
  904    882   
}
  905         -
impl MalformedAcceptWithGenericStringError {
  906         -
    /// Returns `true` if the error kind is `MalformedAcceptWithGenericStringError::InternalServerError`.
  907         -
    pub fn is_internal_server_error(&self) -> bool {
         883  +
impl HttpRequestWithRegexLiteralError {
         884  +
    /// Returns `true` if the error kind is `HttpRequestWithRegexLiteralError::ValidationException`.
         885  +
    pub fn is_validation_exception(&self) -> bool {
  908    886   
        matches!(
  909    887   
            &self,
  910         -
            MalformedAcceptWithGenericStringError::InternalServerError(_)
         888  +
            HttpRequestWithRegexLiteralError::ValidationException(_)
  911    889   
        )
  912    890   
    }
  913         -
    /// Returns the error name string by matching the correct variant.
  914         -
    pub fn name(&self) -> &'static str {
         891  +
    /// Returns `true` if the error kind is `HttpRequestWithRegexLiteralError::InternalServerError`.
         892  +
    pub fn is_internal_server_error(&self) -> bool {
         893  +
        matches!(
         894  +
            &self,
         895  +
            HttpRequestWithRegexLiteralError::InternalServerError(_)
         896  +
        )
         897  +
    }
         898  +
    /// Returns the error name string by matching the correct variant.
         899  +
    pub fn name(&self) -> &'static str {
  915    900   
        match &self {
  916         -
            MalformedAcceptWithGenericStringError::InternalServerError(_inner) => _inner.name(),
         901  +
            HttpRequestWithRegexLiteralError::ValidationException(_inner) => _inner.name(),
         902  +
            HttpRequestWithRegexLiteralError::InternalServerError(_inner) => _inner.name(),
  917    903   
        }
  918    904   
    }
  919    905   
}
  920         -
impl ::std::error::Error for MalformedAcceptWithGenericStringError {
         906  +
impl ::std::error::Error for HttpRequestWithRegexLiteralError {
  921    907   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  922    908   
        match &self {
  923         -
            MalformedAcceptWithGenericStringError::InternalServerError(_inner) => Some(_inner),
         909  +
            HttpRequestWithRegexLiteralError::ValidationException(_inner) => Some(_inner),
         910  +
            HttpRequestWithRegexLiteralError::InternalServerError(_inner) => Some(_inner),
  924    911   
        }
  925    912   
    }
  926    913   
}
         914  +
impl ::std::convert::From<crate::error::ValidationException>
         915  +
    for crate::error::HttpRequestWithRegexLiteralError
         916  +
{
         917  +
    fn from(
         918  +
        variant: crate::error::ValidationException,
         919  +
    ) -> crate::error::HttpRequestWithRegexLiteralError {
         920  +
        Self::ValidationException(variant)
         921  +
    }
         922  +
}
  927    923   
impl ::std::convert::From<crate::error::InternalServerError>
  928         -
    for crate::error::MalformedAcceptWithGenericStringError
         924  +
    for crate::error::HttpRequestWithRegexLiteralError
  929    925   
{
  930    926   
    fn from(
  931    927   
        variant: crate::error::InternalServerError,
  932         -
    ) -> crate::error::MalformedAcceptWithGenericStringError {
         928  +
    ) -> crate::error::HttpRequestWithRegexLiteralError {
  933    929   
        Self::InternalServerError(variant)
  934    930   
    }
  935    931   
}
  936    932   
  937         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedAcceptWithGenericStringError {
  938         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedAcceptWithGenericStringError {
         933  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithRegexLiteralError {
         934  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithRegexLiteralError {
  939    935   
        ::pyo3::Python::with_gil(|py| {
  940    936   
            let error = variant.value(py);
  941         -
         937  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
         938  +
                return error.into();
         939  +
            }
  942    940   
            crate::error::InternalServerError {
  943    941   
                message: error.to_string(),
  944    942   
            }
  945    943   
            .into()
  946    944   
        })
  947    945   
    }
  948    946   
}
  949    947   
  950         -
/// Error type for the `MalformedAcceptWithPayload` operation.
  951         -
/// Each variant represents an error that can occur for the `MalformedAcceptWithPayload` operation.
         948  +
/// Error type for the `AllQueryStringTypes` operation.
         949  +
/// Each variant represents an error that can occur for the `AllQueryStringTypes` operation.
  952    950   
#[derive(::std::fmt::Debug)]
  953         -
pub enum MalformedAcceptWithPayloadError {
         951  +
pub enum AllQueryStringTypesError {
         952  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
         953  +
    ValidationException(crate::error::ValidationException),
  954    954   
    #[allow(missing_docs)] // documentation missing in model
  955    955   
    InternalServerError(crate::error::InternalServerError),
  956    956   
}
  957         -
impl ::std::fmt::Display for MalformedAcceptWithPayloadError {
         957  +
impl ::std::fmt::Display for AllQueryStringTypesError {
  958    958   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  959    959   
        match &self {
  960         -
            MalformedAcceptWithPayloadError::InternalServerError(_inner) => _inner.fmt(f),
         960  +
            AllQueryStringTypesError::ValidationException(_inner) => _inner.fmt(f),
         961  +
            AllQueryStringTypesError::InternalServerError(_inner) => _inner.fmt(f),
  961    962   
        }
  962    963   
    }
  963    964   
}
  964         -
impl MalformedAcceptWithPayloadError {
  965         -
    /// Returns `true` if the error kind is `MalformedAcceptWithPayloadError::InternalServerError`.
         965  +
impl AllQueryStringTypesError {
         966  +
    /// Returns `true` if the error kind is `AllQueryStringTypesError::ValidationException`.
         967  +
    pub fn is_validation_exception(&self) -> bool {
         968  +
        matches!(&self, AllQueryStringTypesError::ValidationException(_))
         969  +
    }
         970  +
    /// Returns `true` if the error kind is `AllQueryStringTypesError::InternalServerError`.
  966    971   
    pub fn is_internal_server_error(&self) -> bool {
  967         -
        matches!(
  968         -
            &self,
  969         -
            MalformedAcceptWithPayloadError::InternalServerError(_)
  970         -
        )
         972  +
        matches!(&self, AllQueryStringTypesError::InternalServerError(_))
  971    973   
    }
  972    974   
    /// Returns the error name string by matching the correct variant.
  973    975   
    pub fn name(&self) -> &'static str {
  974    976   
        match &self {
  975         -
            MalformedAcceptWithPayloadError::InternalServerError(_inner) => _inner.name(),
         977  +
            AllQueryStringTypesError::ValidationException(_inner) => _inner.name(),
         978  +
            AllQueryStringTypesError::InternalServerError(_inner) => _inner.name(),
  976    979   
        }
  977    980   
    }
  978    981   
}
  979         -
impl ::std::error::Error for MalformedAcceptWithPayloadError {
         982  +
impl ::std::error::Error for AllQueryStringTypesError {
  980    983   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
  981    984   
        match &self {
  982         -
            MalformedAcceptWithPayloadError::InternalServerError(_inner) => Some(_inner),
         985  +
            AllQueryStringTypesError::ValidationException(_inner) => Some(_inner),
         986  +
            AllQueryStringTypesError::InternalServerError(_inner) => Some(_inner),
  983    987   
        }
  984    988   
    }
  985    989   
}
         990  +
impl ::std::convert::From<crate::error::ValidationException>
         991  +
    for crate::error::AllQueryStringTypesError
         992  +
{
         993  +
    fn from(variant: crate::error::ValidationException) -> crate::error::AllQueryStringTypesError {
         994  +
        Self::ValidationException(variant)
         995  +
    }
         996  +
}
  986    997   
impl ::std::convert::From<crate::error::InternalServerError>
  987         -
    for crate::error::MalformedAcceptWithPayloadError
         998  +
    for crate::error::AllQueryStringTypesError
  988    999   
{
  989         -
    fn from(
  990         -
        variant: crate::error::InternalServerError,
  991         -
    ) -> crate::error::MalformedAcceptWithPayloadError {
        1000  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::AllQueryStringTypesError {
  992   1001   
        Self::InternalServerError(variant)
  993   1002   
    }
  994   1003   
}
  995   1004   
  996         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedAcceptWithPayloadError {
  997         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedAcceptWithPayloadError {
        1005  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::AllQueryStringTypesError {
        1006  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::AllQueryStringTypesError {
  998   1007   
        ::pyo3::Python::with_gil(|py| {
  999   1008   
            let error = variant.value(py);
 1000         -
        1009  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        1010  +
                return error.into();
        1011  +
            }
 1001   1012   
            crate::error::InternalServerError {
 1002   1013   
                message: error.to_string(),
 1003   1014   
            }
 1004   1015   
            .into()
 1005   1016   
        })
 1006   1017   
    }
 1007   1018   
}
 1008   1019   
 1009         -
/// Error type for the `MalformedAcceptWithBody` operation.
 1010         -
/// Each variant represents an error that can occur for the `MalformedAcceptWithBody` operation.
        1020  +
/// Error type for the `ConstantQueryString` operation.
        1021  +
/// Each variant represents an error that can occur for the `ConstantQueryString` operation.
 1011   1022   
#[derive(::std::fmt::Debug)]
 1012         -
pub enum MalformedAcceptWithBodyError {
        1023  +
pub enum ConstantQueryStringError {
        1024  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        1025  +
    ValidationException(crate::error::ValidationException),
 1013   1026   
    #[allow(missing_docs)] // documentation missing in model
 1014   1027   
    InternalServerError(crate::error::InternalServerError),
 1015   1028   
}
 1016         -
impl ::std::fmt::Display for MalformedAcceptWithBodyError {
        1029  +
impl ::std::fmt::Display for ConstantQueryStringError {
 1017   1030   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1018   1031   
        match &self {
 1019         -
            MalformedAcceptWithBodyError::InternalServerError(_inner) => _inner.fmt(f),
        1032  +
            ConstantQueryStringError::ValidationException(_inner) => _inner.fmt(f),
        1033  +
            ConstantQueryStringError::InternalServerError(_inner) => _inner.fmt(f),
 1020   1034   
        }
 1021   1035   
    }
 1022   1036   
}
 1023         -
impl MalformedAcceptWithBodyError {
 1024         -
    /// Returns `true` if the error kind is `MalformedAcceptWithBodyError::InternalServerError`.
        1037  +
impl ConstantQueryStringError {
        1038  +
    /// Returns `true` if the error kind is `ConstantQueryStringError::ValidationException`.
        1039  +
    pub fn is_validation_exception(&self) -> bool {
        1040  +
        matches!(&self, ConstantQueryStringError::ValidationException(_))
        1041  +
    }
        1042  +
    /// Returns `true` if the error kind is `ConstantQueryStringError::InternalServerError`.
 1025   1043   
    pub fn is_internal_server_error(&self) -> bool {
 1026         -
        matches!(&self, MalformedAcceptWithBodyError::InternalServerError(_))
        1044  +
        matches!(&self, ConstantQueryStringError::InternalServerError(_))
 1027   1045   
    }
 1028   1046   
    /// Returns the error name string by matching the correct variant.
 1029   1047   
    pub fn name(&self) -> &'static str {
 1030   1048   
        match &self {
 1031         -
            MalformedAcceptWithBodyError::InternalServerError(_inner) => _inner.name(),
        1049  +
            ConstantQueryStringError::ValidationException(_inner) => _inner.name(),
        1050  +
            ConstantQueryStringError::InternalServerError(_inner) => _inner.name(),
 1032   1051   
        }
 1033   1052   
    }
 1034   1053   
}
 1035         -
impl ::std::error::Error for MalformedAcceptWithBodyError {
        1054  +
impl ::std::error::Error for ConstantQueryStringError {
 1036   1055   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1037   1056   
        match &self {
 1038         -
            MalformedAcceptWithBodyError::InternalServerError(_inner) => Some(_inner),
        1057  +
            ConstantQueryStringError::ValidationException(_inner) => Some(_inner),
        1058  +
            ConstantQueryStringError::InternalServerError(_inner) => Some(_inner),
 1039   1059   
        }
 1040   1060   
    }
 1041   1061   
}
        1062  +
impl ::std::convert::From<crate::error::ValidationException>
        1063  +
    for crate::error::ConstantQueryStringError
        1064  +
{
        1065  +
    fn from(variant: crate::error::ValidationException) -> crate::error::ConstantQueryStringError {
        1066  +
        Self::ValidationException(variant)
        1067  +
    }
        1068  +
}
 1042   1069   
impl ::std::convert::From<crate::error::InternalServerError>
 1043         -
    for crate::error::MalformedAcceptWithBodyError
        1070  +
    for crate::error::ConstantQueryStringError
 1044   1071   
{
 1045         -
    fn from(
 1046         -
        variant: crate::error::InternalServerError,
 1047         -
    ) -> crate::error::MalformedAcceptWithBodyError {
        1072  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::ConstantQueryStringError {
 1048   1073   
        Self::InternalServerError(variant)
 1049   1074   
    }
 1050   1075   
}
 1051   1076   
 1052         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedAcceptWithBodyError {
 1053         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedAcceptWithBodyError {
        1077  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ConstantQueryStringError {
        1078  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::ConstantQueryStringError {
 1054   1079   
        ::pyo3::Python::with_gil(|py| {
 1055   1080   
            let error = variant.value(py);
 1056         -
        1081  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        1082  +
                return error.into();
        1083  +
            }
 1057   1084   
            crate::error::InternalServerError {
 1058   1085   
                message: error.to_string(),
 1059   1086   
            }
 1060   1087   
            .into()
 1061   1088   
        })
 1062   1089   
    }
 1063   1090   
}
 1064   1091   
 1065         -
/// Error type for the `MalformedContentTypeWithGenericString` operation.
 1066         -
/// Each variant represents an error that can occur for the `MalformedContentTypeWithGenericString` operation.
        1092  +
/// Error type for the `ConstantAndVariableQueryString` operation.
        1093  +
/// Each variant represents an error that can occur for the `ConstantAndVariableQueryString` operation.
 1067   1094   
#[derive(::std::fmt::Debug)]
 1068         -
pub enum MalformedContentTypeWithGenericStringError {
        1095  +
pub enum ConstantAndVariableQueryStringError {
 1069   1096   
    #[allow(missing_docs)] // documentation missing in model
 1070   1097   
    InternalServerError(crate::error::InternalServerError),
 1071   1098   
}
 1072         -
impl ::std::fmt::Display for MalformedContentTypeWithGenericStringError {
        1099  +
impl ::std::fmt::Display for ConstantAndVariableQueryStringError {
 1073   1100   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1074   1101   
        match &self {
 1075         -
            MalformedContentTypeWithGenericStringError::InternalServerError(_inner) => {
 1076         -
                _inner.fmt(f)
 1077         -
            }
        1102  +
            ConstantAndVariableQueryStringError::InternalServerError(_inner) => _inner.fmt(f),
 1078   1103   
        }
 1079   1104   
    }
 1080   1105   
}
 1081         -
impl MalformedContentTypeWithGenericStringError {
 1082         -
    /// Returns `true` if the error kind is `MalformedContentTypeWithGenericStringError::InternalServerError`.
        1106  +
impl ConstantAndVariableQueryStringError {
        1107  +
    /// Returns `true` if the error kind is `ConstantAndVariableQueryStringError::InternalServerError`.
 1083   1108   
    pub fn is_internal_server_error(&self) -> bool {
 1084   1109   
        matches!(
 1085   1110   
            &self,
 1086         -
            MalformedContentTypeWithGenericStringError::InternalServerError(_)
        1111  +
            ConstantAndVariableQueryStringError::InternalServerError(_)
 1087   1112   
        )
 1088   1113   
    }
 1089   1114   
    /// Returns the error name string by matching the correct variant.
 1090   1115   
    pub fn name(&self) -> &'static str {
 1091   1116   
        match &self {
 1092         -
            MalformedContentTypeWithGenericStringError::InternalServerError(_inner) => {
 1093         -
                _inner.name()
 1094         -
            }
        1117  +
            ConstantAndVariableQueryStringError::InternalServerError(_inner) => _inner.name(),
 1095   1118   
        }
 1096   1119   
    }
 1097   1120   
}
 1098         -
impl ::std::error::Error for MalformedContentTypeWithGenericStringError {
        1121  +
impl ::std::error::Error for ConstantAndVariableQueryStringError {
 1099   1122   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1100   1123   
        match &self {
 1101         -
            MalformedContentTypeWithGenericStringError::InternalServerError(_inner) => Some(_inner),
        1124  +
            ConstantAndVariableQueryStringError::InternalServerError(_inner) => Some(_inner),
 1102   1125   
        }
 1103   1126   
    }
 1104   1127   
}
 1105   1128   
impl ::std::convert::From<crate::error::InternalServerError>
 1106         -
    for crate::error::MalformedContentTypeWithGenericStringError
        1129  +
    for crate::error::ConstantAndVariableQueryStringError
 1107   1130   
{
 1108   1131   
    fn from(
 1109   1132   
        variant: crate::error::InternalServerError,
 1110         -
    ) -> crate::error::MalformedContentTypeWithGenericStringError {
        1133  +
    ) -> crate::error::ConstantAndVariableQueryStringError {
 1111   1134   
        Self::InternalServerError(variant)
 1112   1135   
    }
 1113   1136   
}
 1114   1137   
 1115         -
impl ::std::convert::From<::pyo3::PyErr>
 1116         -
    for crate::error::MalformedContentTypeWithGenericStringError
 1117         -
{
 1118         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithGenericStringError {
        1138  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ConstantAndVariableQueryStringError {
        1139  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::ConstantAndVariableQueryStringError {
 1119   1140   
        ::pyo3::Python::with_gil(|py| {
 1120   1141   
            let error = variant.value(py);
 1121   1142   
 1122   1143   
            crate::error::InternalServerError {
 1123   1144   
                message: error.to_string(),
 1124   1145   
            }
 1125   1146   
            .into()
 1126   1147   
        })
 1127   1148   
    }
 1128   1149   
}
 1129   1150   
 1130         -
/// Error type for the `MalformedContentTypeWithPayload` operation.
 1131         -
/// Each variant represents an error that can occur for the `MalformedContentTypeWithPayload` operation.
        1151  +
/// Error type for the `IgnoreQueryParamsInResponse` operation.
        1152  +
/// Each variant represents an error that can occur for the `IgnoreQueryParamsInResponse` operation.
 1132   1153   
#[derive(::std::fmt::Debug)]
 1133         -
pub enum MalformedContentTypeWithPayloadError {
        1154  +
pub enum IgnoreQueryParamsInResponseError {
 1134   1155   
    #[allow(missing_docs)] // documentation missing in model
 1135   1156   
    InternalServerError(crate::error::InternalServerError),
 1136   1157   
}
 1137         -
impl ::std::fmt::Display for MalformedContentTypeWithPayloadError {
        1158  +
impl ::std::fmt::Display for IgnoreQueryParamsInResponseError {
 1138   1159   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1139   1160   
        match &self {
 1140         -
            MalformedContentTypeWithPayloadError::InternalServerError(_inner) => _inner.fmt(f),
        1161  +
            IgnoreQueryParamsInResponseError::InternalServerError(_inner) => _inner.fmt(f),
 1141   1162   
        }
 1142   1163   
    }
 1143   1164   
}
 1144         -
impl MalformedContentTypeWithPayloadError {
 1145         -
    /// Returns `true` if the error kind is `MalformedContentTypeWithPayloadError::InternalServerError`.
        1165  +
impl IgnoreQueryParamsInResponseError {
        1166  +
    /// Returns `true` if the error kind is `IgnoreQueryParamsInResponseError::InternalServerError`.
 1146   1167   
    pub fn is_internal_server_error(&self) -> bool {
 1147   1168   
        matches!(
 1148   1169   
            &self,
 1149         -
            MalformedContentTypeWithPayloadError::InternalServerError(_)
        1170  +
            IgnoreQueryParamsInResponseError::InternalServerError(_)
 1150   1171   
        )
 1151   1172   
    }
 1152   1173   
    /// Returns the error name string by matching the correct variant.
 1153   1174   
    pub fn name(&self) -> &'static str {
 1154   1175   
        match &self {
 1155         -
            MalformedContentTypeWithPayloadError::InternalServerError(_inner) => _inner.name(),
        1176  +
            IgnoreQueryParamsInResponseError::InternalServerError(_inner) => _inner.name(),
 1156   1177   
        }
 1157   1178   
    }
 1158   1179   
}
 1159         -
impl ::std::error::Error for MalformedContentTypeWithPayloadError {
        1180  +
impl ::std::error::Error for IgnoreQueryParamsInResponseError {
 1160   1181   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1161   1182   
        match &self {
 1162         -
            MalformedContentTypeWithPayloadError::InternalServerError(_inner) => Some(_inner),
        1183  +
            IgnoreQueryParamsInResponseError::InternalServerError(_inner) => Some(_inner),
 1163   1184   
        }
 1164   1185   
    }
 1165   1186   
}
 1166   1187   
impl ::std::convert::From<crate::error::InternalServerError>
 1167         -
    for crate::error::MalformedContentTypeWithPayloadError
        1188  +
    for crate::error::IgnoreQueryParamsInResponseError
 1168   1189   
{
 1169   1190   
    fn from(
 1170   1191   
        variant: crate::error::InternalServerError,
 1171         -
    ) -> crate::error::MalformedContentTypeWithPayloadError {
        1192  +
    ) -> crate::error::IgnoreQueryParamsInResponseError {
 1172   1193   
        Self::InternalServerError(variant)
 1173   1194   
    }
 1174   1195   
}
 1175   1196   
 1176         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedContentTypeWithPayloadError {
 1177         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithPayloadError {
        1197  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::IgnoreQueryParamsInResponseError {
        1198  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::IgnoreQueryParamsInResponseError {
 1178   1199   
        ::pyo3::Python::with_gil(|py| {
 1179   1200   
            let error = variant.value(py);
 1180   1201   
 1181   1202   
            crate::error::InternalServerError {
 1182   1203   
                message: error.to_string(),
 1183   1204   
            }
 1184   1205   
            .into()
 1185   1206   
        })
 1186   1207   
    }
 1187   1208   
}
 1188   1209   
 1189         -
/// Error type for the `MalformedContentTypeWithBody` operation.
 1190         -
/// Each variant represents an error that can occur for the `MalformedContentTypeWithBody` operation.
        1210  +
/// Error type for the `OmitsNullSerializesEmptyString` operation.
        1211  +
/// Each variant represents an error that can occur for the `OmitsNullSerializesEmptyString` operation.
 1191   1212   
#[derive(::std::fmt::Debug)]
 1192         -
pub enum MalformedContentTypeWithBodyError {
        1213  +
pub enum OmitsNullSerializesEmptyStringError {
 1193   1214   
    #[allow(missing_docs)] // documentation missing in model
 1194   1215   
    InternalServerError(crate::error::InternalServerError),
 1195   1216   
}
 1196         -
impl ::std::fmt::Display for MalformedContentTypeWithBodyError {
        1217  +
impl ::std::fmt::Display for OmitsNullSerializesEmptyStringError {
 1197   1218   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1198   1219   
        match &self {
 1199         -
            MalformedContentTypeWithBodyError::InternalServerError(_inner) => _inner.fmt(f),
        1220  +
            OmitsNullSerializesEmptyStringError::InternalServerError(_inner) => _inner.fmt(f),
 1200   1221   
        }
 1201   1222   
    }
 1202   1223   
}
 1203         -
impl MalformedContentTypeWithBodyError {
 1204         -
    /// Returns `true` if the error kind is `MalformedContentTypeWithBodyError::InternalServerError`.
        1224  +
impl OmitsNullSerializesEmptyStringError {
        1225  +
    /// Returns `true` if the error kind is `OmitsNullSerializesEmptyStringError::InternalServerError`.
 1205   1226   
    pub fn is_internal_server_error(&self) -> bool {
 1206   1227   
        matches!(
 1207   1228   
            &self,
 1208         -
            MalformedContentTypeWithBodyError::InternalServerError(_)
        1229  +
            OmitsNullSerializesEmptyStringError::InternalServerError(_)
 1209   1230   
        )
 1210   1231   
    }
 1211   1232   
    /// Returns the error name string by matching the correct variant.
 1212   1233   
    pub fn name(&self) -> &'static str {
 1213   1234   
        match &self {
 1214         -
            MalformedContentTypeWithBodyError::InternalServerError(_inner) => _inner.name(),
        1235  +
            OmitsNullSerializesEmptyStringError::InternalServerError(_inner) => _inner.name(),
 1215   1236   
        }
 1216   1237   
    }
 1217   1238   
}
 1218         -
impl ::std::error::Error for MalformedContentTypeWithBodyError {
        1239  +
impl ::std::error::Error for OmitsNullSerializesEmptyStringError {
 1219   1240   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1220   1241   
        match &self {
 1221         -
            MalformedContentTypeWithBodyError::InternalServerError(_inner) => Some(_inner),
        1242  +
            OmitsNullSerializesEmptyStringError::InternalServerError(_inner) => Some(_inner),
 1222   1243   
        }
 1223   1244   
    }
 1224   1245   
}
 1225   1246   
impl ::std::convert::From<crate::error::InternalServerError>
 1226         -
    for crate::error::MalformedContentTypeWithBodyError
        1247  +
    for crate::error::OmitsNullSerializesEmptyStringError
 1227   1248   
{
 1228   1249   
    fn from(
 1229   1250   
        variant: crate::error::InternalServerError,
 1230         -
    ) -> crate::error::MalformedContentTypeWithBodyError {
        1251  +
    ) -> crate::error::OmitsNullSerializesEmptyStringError {
 1231   1252   
        Self::InternalServerError(variant)
 1232   1253   
    }
 1233   1254   
}
 1234   1255   
 1235         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedContentTypeWithBodyError {
 1236         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithBodyError {
        1256  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OmitsNullSerializesEmptyStringError {
        1257  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::OmitsNullSerializesEmptyStringError {
 1237   1258   
        ::pyo3::Python::with_gil(|py| {
 1238   1259   
            let error = variant.value(py);
 1239   1260   
 1240   1261   
            crate::error::InternalServerError {
 1241   1262   
                message: error.to_string(),
 1242   1263   
            }
 1243   1264   
            .into()
 1244   1265   
        })
 1245   1266   
    }
 1246   1267   
}
 1247   1268   
 1248         -
/// Error type for the `MalformedContentTypeWithoutBodyEmptyInput` operation.
 1249         -
/// Each variant represents an error that can occur for the `MalformedContentTypeWithoutBodyEmptyInput` operation.
        1269  +
/// Error type for the `OmitsSerializingEmptyLists` operation.
        1270  +
/// Each variant represents an error that can occur for the `OmitsSerializingEmptyLists` operation.
 1250   1271   
#[derive(::std::fmt::Debug)]
 1251         -
pub enum MalformedContentTypeWithoutBodyEmptyInputError {
        1272  +
pub enum OmitsSerializingEmptyListsError {
        1273  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        1274  +
    ValidationException(crate::error::ValidationException),
 1252   1275   
    #[allow(missing_docs)] // documentation missing in model
 1253   1276   
    InternalServerError(crate::error::InternalServerError),
 1254   1277   
}
 1255         -
impl ::std::fmt::Display for MalformedContentTypeWithoutBodyEmptyInputError {
        1278  +
impl ::std::fmt::Display for OmitsSerializingEmptyListsError {
 1256   1279   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1257   1280   
        match &self {
 1258         -
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_inner) => {
 1259         -
                _inner.fmt(f)
 1260         -
            }
        1281  +
            OmitsSerializingEmptyListsError::ValidationException(_inner) => _inner.fmt(f),
        1282  +
            OmitsSerializingEmptyListsError::InternalServerError(_inner) => _inner.fmt(f),
 1261   1283   
        }
 1262   1284   
    }
 1263   1285   
}
 1264         -
impl MalformedContentTypeWithoutBodyEmptyInputError {
 1265         -
    /// Returns `true` if the error kind is `MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError`.
        1286  +
impl OmitsSerializingEmptyListsError {
        1287  +
    /// Returns `true` if the error kind is `OmitsSerializingEmptyListsError::ValidationException`.
        1288  +
    pub fn is_validation_exception(&self) -> bool {
        1289  +
        matches!(
        1290  +
            &self,
        1291  +
            OmitsSerializingEmptyListsError::ValidationException(_)
        1292  +
        )
        1293  +
    }
        1294  +
    /// Returns `true` if the error kind is `OmitsSerializingEmptyListsError::InternalServerError`.
 1266   1295   
    pub fn is_internal_server_error(&self) -> bool {
 1267   1296   
        matches!(
 1268   1297   
            &self,
 1269         -
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_)
        1298  +
            OmitsSerializingEmptyListsError::InternalServerError(_)
 1270   1299   
        )
 1271   1300   
    }
 1272   1301   
    /// Returns the error name string by matching the correct variant.
 1273   1302   
    pub fn name(&self) -> &'static str {
 1274   1303   
        match &self {
 1275         -
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_inner) => {
 1276         -
                _inner.name()
 1277         -
            }
        1304  +
            OmitsSerializingEmptyListsError::ValidationException(_inner) => _inner.name(),
        1305  +
            OmitsSerializingEmptyListsError::InternalServerError(_inner) => _inner.name(),
 1278   1306   
        }
 1279   1307   
    }
 1280   1308   
}
 1281         -
impl ::std::error::Error for MalformedContentTypeWithoutBodyEmptyInputError {
        1309  +
impl ::std::error::Error for OmitsSerializingEmptyListsError {
 1282   1310   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1283   1311   
        match &self {
 1284         -
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_inner) => {
 1285         -
                Some(_inner)
 1286         -
            }
        1312  +
            OmitsSerializingEmptyListsError::ValidationException(_inner) => Some(_inner),
        1313  +
            OmitsSerializingEmptyListsError::InternalServerError(_inner) => Some(_inner),
 1287   1314   
        }
 1288   1315   
    }
 1289   1316   
}
        1317  +
impl ::std::convert::From<crate::error::ValidationException>
        1318  +
    for crate::error::OmitsSerializingEmptyListsError
        1319  +
{
        1320  +
    fn from(
        1321  +
        variant: crate::error::ValidationException,
        1322  +
    ) -> crate::error::OmitsSerializingEmptyListsError {
        1323  +
        Self::ValidationException(variant)
        1324  +
    }
        1325  +
}
 1290   1326   
impl ::std::convert::From<crate::error::InternalServerError>
 1291         -
    for crate::error::MalformedContentTypeWithoutBodyEmptyInputError
        1327  +
    for crate::error::OmitsSerializingEmptyListsError
 1292   1328   
{
 1293   1329   
    fn from(
 1294   1330   
        variant: crate::error::InternalServerError,
 1295         -
    ) -> crate::error::MalformedContentTypeWithoutBodyEmptyInputError {
        1331  +
    ) -> crate::error::OmitsSerializingEmptyListsError {
 1296   1332   
        Self::InternalServerError(variant)
 1297   1333   
    }
 1298   1334   
}
 1299   1335   
 1300         -
impl ::std::convert::From<::pyo3::PyErr>
 1301         -
    for crate::error::MalformedContentTypeWithoutBodyEmptyInputError
 1302         -
{
 1303         -
    fn from(
 1304         -
        variant: ::pyo3::PyErr,
 1305         -
    ) -> crate::error::MalformedContentTypeWithoutBodyEmptyInputError {
        1336  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OmitsSerializingEmptyListsError {
        1337  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::OmitsSerializingEmptyListsError {
 1306   1338   
        ::pyo3::Python::with_gil(|py| {
 1307   1339   
            let error = variant.value(py);
 1308         -
        1340  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        1341  +
                return error.into();
        1342  +
            }
 1309   1343   
            crate::error::InternalServerError {
 1310   1344   
                message: error.to_string(),
 1311   1345   
            }
 1312   1346   
            .into()
 1313   1347   
        })
 1314   1348   
    }
 1315   1349   
}
 1316   1350   
 1317         -
/// Error type for the `MalformedContentTypeWithoutBody` operation.
 1318         -
/// Each variant represents an error that can occur for the `MalformedContentTypeWithoutBody` operation.
        1351  +
/// Error type for the `QueryIdempotencyTokenAutoFill` operation.
        1352  +
/// Each variant represents an error that can occur for the `QueryIdempotencyTokenAutoFill` operation.
 1319   1353   
#[derive(::std::fmt::Debug)]
 1320         -
pub enum MalformedContentTypeWithoutBodyError {
        1354  +
pub enum QueryIdempotencyTokenAutoFillError {
 1321   1355   
    #[allow(missing_docs)] // documentation missing in model
 1322   1356   
    InternalServerError(crate::error::InternalServerError),
 1323   1357   
}
 1324         -
impl ::std::fmt::Display for MalformedContentTypeWithoutBodyError {
        1358  +
impl ::std::fmt::Display for QueryIdempotencyTokenAutoFillError {
 1325   1359   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1326   1360   
        match &self {
 1327         -
            MalformedContentTypeWithoutBodyError::InternalServerError(_inner) => _inner.fmt(f),
        1361  +
            QueryIdempotencyTokenAutoFillError::InternalServerError(_inner) => _inner.fmt(f),
 1328   1362   
        }
 1329   1363   
    }
 1330   1364   
}
 1331         -
impl MalformedContentTypeWithoutBodyError {
 1332         -
    /// Returns `true` if the error kind is `MalformedContentTypeWithoutBodyError::InternalServerError`.
        1365  +
impl QueryIdempotencyTokenAutoFillError {
        1366  +
    /// Returns `true` if the error kind is `QueryIdempotencyTokenAutoFillError::InternalServerError`.
 1333   1367   
    pub fn is_internal_server_error(&self) -> bool {
 1334   1368   
        matches!(
 1335   1369   
            &self,
 1336         -
            MalformedContentTypeWithoutBodyError::InternalServerError(_)
        1370  +
            QueryIdempotencyTokenAutoFillError::InternalServerError(_)
 1337   1371   
        )
 1338   1372   
    }
 1339   1373   
    /// Returns the error name string by matching the correct variant.
 1340   1374   
    pub fn name(&self) -> &'static str {
 1341   1375   
        match &self {
 1342         -
            MalformedContentTypeWithoutBodyError::InternalServerError(_inner) => _inner.name(),
        1376  +
            QueryIdempotencyTokenAutoFillError::InternalServerError(_inner) => _inner.name(),
 1343   1377   
        }
 1344   1378   
    }
 1345   1379   
}
 1346         -
impl ::std::error::Error for MalformedContentTypeWithoutBodyError {
        1380  +
impl ::std::error::Error for QueryIdempotencyTokenAutoFillError {
 1347   1381   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1348   1382   
        match &self {
 1349         -
            MalformedContentTypeWithoutBodyError::InternalServerError(_inner) => Some(_inner),
        1383  +
            QueryIdempotencyTokenAutoFillError::InternalServerError(_inner) => Some(_inner),
 1350   1384   
        }
 1351   1385   
    }
 1352   1386   
}
 1353   1387   
impl ::std::convert::From<crate::error::InternalServerError>
 1354         -
    for crate::error::MalformedContentTypeWithoutBodyError
        1388  +
    for crate::error::QueryIdempotencyTokenAutoFillError
 1355   1389   
{
 1356   1390   
    fn from(
 1357   1391   
        variant: crate::error::InternalServerError,
 1358         -
    ) -> crate::error::MalformedContentTypeWithoutBodyError {
        1392  +
    ) -> crate::error::QueryIdempotencyTokenAutoFillError {
 1359   1393   
        Self::InternalServerError(variant)
 1360   1394   
    }
 1361   1395   
}
 1362   1396   
 1363         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedContentTypeWithoutBodyError {
 1364         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithoutBodyError {
        1397  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryIdempotencyTokenAutoFillError {
        1398  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::QueryIdempotencyTokenAutoFillError {
 1365   1399   
        ::pyo3::Python::with_gil(|py| {
 1366   1400   
            let error = variant.value(py);
 1367   1401   
 1368   1402   
            crate::error::InternalServerError {
 1369   1403   
                message: error.to_string(),
 1370   1404   
            }
 1371   1405   
            .into()
 1372   1406   
        })
 1373   1407   
    }
 1374   1408   
}
 1375   1409   
 1376         -
/// Error type for the `MalformedTimestampBodyHttpDate` operation.
 1377         -
/// Each variant represents an error that can occur for the `MalformedTimestampBodyHttpDate` operation.
        1410  +
/// Error type for the `QueryPrecedence` operation.
        1411  +
/// Each variant represents an error that can occur for the `QueryPrecedence` operation.
 1378   1412   
#[derive(::std::fmt::Debug)]
 1379         -
pub enum MalformedTimestampBodyHttpDateError {
 1380         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1381         -
    ValidationException(crate::error::ValidationException),
        1413  +
pub enum QueryPrecedenceError {
 1382   1414   
    #[allow(missing_docs)] // documentation missing in model
 1383   1415   
    InternalServerError(crate::error::InternalServerError),
 1384   1416   
}
 1385         -
impl ::std::fmt::Display for MalformedTimestampBodyHttpDateError {
        1417  +
impl ::std::fmt::Display for QueryPrecedenceError {
 1386   1418   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1387   1419   
        match &self {
 1388         -
            MalformedTimestampBodyHttpDateError::ValidationException(_inner) => _inner.fmt(f),
 1389         -
            MalformedTimestampBodyHttpDateError::InternalServerError(_inner) => _inner.fmt(f),
        1420  +
            QueryPrecedenceError::InternalServerError(_inner) => _inner.fmt(f),
 1390   1421   
        }
 1391   1422   
    }
 1392   1423   
}
 1393         -
impl MalformedTimestampBodyHttpDateError {
 1394         -
    /// Returns `true` if the error kind is `MalformedTimestampBodyHttpDateError::ValidationException`.
 1395         -
    pub fn is_validation_exception(&self) -> bool {
 1396         -
        matches!(
 1397         -
            &self,
 1398         -
            MalformedTimestampBodyHttpDateError::ValidationException(_)
 1399         -
        )
 1400         -
    }
 1401         -
    /// Returns `true` if the error kind is `MalformedTimestampBodyHttpDateError::InternalServerError`.
        1424  +
impl QueryPrecedenceError {
        1425  +
    /// Returns `true` if the error kind is `QueryPrecedenceError::InternalServerError`.
 1402   1426   
    pub fn is_internal_server_error(&self) -> bool {
 1403         -
        matches!(
 1404         -
            &self,
 1405         -
            MalformedTimestampBodyHttpDateError::InternalServerError(_)
 1406         -
        )
        1427  +
        matches!(&self, QueryPrecedenceError::InternalServerError(_))
 1407   1428   
    }
 1408   1429   
    /// Returns the error name string by matching the correct variant.
 1409   1430   
    pub fn name(&self) -> &'static str {
 1410   1431   
        match &self {
 1411         -
            MalformedTimestampBodyHttpDateError::ValidationException(_inner) => _inner.name(),
 1412         -
            MalformedTimestampBodyHttpDateError::InternalServerError(_inner) => _inner.name(),
        1432  +
            QueryPrecedenceError::InternalServerError(_inner) => _inner.name(),
 1413   1433   
        }
 1414   1434   
    }
 1415   1435   
}
 1416         -
impl ::std::error::Error for MalformedTimestampBodyHttpDateError {
        1436  +
impl ::std::error::Error for QueryPrecedenceError {
 1417   1437   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1418   1438   
        match &self {
 1419         -
            MalformedTimestampBodyHttpDateError::ValidationException(_inner) => Some(_inner),
 1420         -
            MalformedTimestampBodyHttpDateError::InternalServerError(_inner) => Some(_inner),
        1439  +
            QueryPrecedenceError::InternalServerError(_inner) => Some(_inner),
 1421   1440   
        }
 1422   1441   
    }
 1423   1442   
}
 1424         -
impl ::std::convert::From<crate::error::ValidationException>
 1425         -
    for crate::error::MalformedTimestampBodyHttpDateError
 1426         -
{
 1427         -
    fn from(
 1428         -
        variant: crate::error::ValidationException,
 1429         -
    ) -> crate::error::MalformedTimestampBodyHttpDateError {
 1430         -
        Self::ValidationException(variant)
 1431         -
    }
 1432         -
}
 1433   1443   
impl ::std::convert::From<crate::error::InternalServerError>
 1434         -
    for crate::error::MalformedTimestampBodyHttpDateError
        1444  +
    for crate::error::QueryPrecedenceError
 1435   1445   
{
 1436         -
    fn from(
 1437         -
        variant: crate::error::InternalServerError,
 1438         -
    ) -> crate::error::MalformedTimestampBodyHttpDateError {
        1446  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::QueryPrecedenceError {
 1439   1447   
        Self::InternalServerError(variant)
 1440   1448   
    }
 1441   1449   
}
 1442   1450   
 1443         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampBodyHttpDateError {
 1444         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampBodyHttpDateError {
        1451  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryPrecedenceError {
        1452  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::QueryPrecedenceError {
 1445   1453   
        ::pyo3::Python::with_gil(|py| {
 1446   1454   
            let error = variant.value(py);
 1447         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 1448         -
                return error.into();
 1449         -
            }
        1455  +
 1450   1456   
            crate::error::InternalServerError {
 1451   1457   
                message: error.to_string(),
 1452   1458   
            }
 1453   1459   
            .into()
 1454   1460   
        })
 1455   1461   
    }
 1456   1462   
}
 1457   1463   
 1458         -
/// Error type for the `MalformedTimestampBodyDateTime` operation.
 1459         -
/// Each variant represents an error that can occur for the `MalformedTimestampBodyDateTime` operation.
        1464  +
/// Error type for the `HttpQueryParamsOnlyOperation` operation.
        1465  +
/// Each variant represents an error that can occur for the `HttpQueryParamsOnlyOperation` operation.
 1460   1466   
#[derive(::std::fmt::Debug)]
 1461         -
pub enum MalformedTimestampBodyDateTimeError {
 1462         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1463         -
    ValidationException(crate::error::ValidationException),
        1467  +
pub enum HttpQueryParamsOnlyOperationError {
 1464   1468   
    #[allow(missing_docs)] // documentation missing in model
 1465   1469   
    InternalServerError(crate::error::InternalServerError),
 1466   1470   
}
 1467         -
impl ::std::fmt::Display for MalformedTimestampBodyDateTimeError {
        1471  +
impl ::std::fmt::Display for HttpQueryParamsOnlyOperationError {
 1468   1472   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1469   1473   
        match &self {
 1470         -
            MalformedTimestampBodyDateTimeError::ValidationException(_inner) => _inner.fmt(f),
 1471         -
            MalformedTimestampBodyDateTimeError::InternalServerError(_inner) => _inner.fmt(f),
        1474  +
            HttpQueryParamsOnlyOperationError::InternalServerError(_inner) => _inner.fmt(f),
 1472   1475   
        }
 1473   1476   
    }
 1474   1477   
}
 1475         -
impl MalformedTimestampBodyDateTimeError {
 1476         -
    /// Returns `true` if the error kind is `MalformedTimestampBodyDateTimeError::ValidationException`.
 1477         -
    pub fn is_validation_exception(&self) -> bool {
 1478         -
        matches!(
 1479         -
            &self,
 1480         -
            MalformedTimestampBodyDateTimeError::ValidationException(_)
 1481         -
        )
 1482         -
    }
 1483         -
    /// Returns `true` if the error kind is `MalformedTimestampBodyDateTimeError::InternalServerError`.
        1478  +
impl HttpQueryParamsOnlyOperationError {
        1479  +
    /// Returns `true` if the error kind is `HttpQueryParamsOnlyOperationError::InternalServerError`.
 1484   1480   
    pub fn is_internal_server_error(&self) -> bool {
 1485   1481   
        matches!(
 1486   1482   
            &self,
 1487         -
            MalformedTimestampBodyDateTimeError::InternalServerError(_)
        1483  +
            HttpQueryParamsOnlyOperationError::InternalServerError(_)
 1488   1484   
        )
 1489   1485   
    }
 1490   1486   
    /// Returns the error name string by matching the correct variant.
 1491   1487   
    pub fn name(&self) -> &'static str {
 1492   1488   
        match &self {
 1493         -
            MalformedTimestampBodyDateTimeError::ValidationException(_inner) => _inner.name(),
 1494         -
            MalformedTimestampBodyDateTimeError::InternalServerError(_inner) => _inner.name(),
        1489  +
            HttpQueryParamsOnlyOperationError::InternalServerError(_inner) => _inner.name(),
 1495   1490   
        }
 1496   1491   
    }
 1497   1492   
}
 1498         -
impl ::std::error::Error for MalformedTimestampBodyDateTimeError {
        1493  +
impl ::std::error::Error for HttpQueryParamsOnlyOperationError {
 1499   1494   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1500   1495   
        match &self {
 1501         -
            MalformedTimestampBodyDateTimeError::ValidationException(_inner) => Some(_inner),
 1502         -
            MalformedTimestampBodyDateTimeError::InternalServerError(_inner) => Some(_inner),
        1496  +
            HttpQueryParamsOnlyOperationError::InternalServerError(_inner) => Some(_inner),
 1503   1497   
        }
 1504   1498   
    }
 1505   1499   
}
 1506         -
impl ::std::convert::From<crate::error::ValidationException>
 1507         -
    for crate::error::MalformedTimestampBodyDateTimeError
 1508         -
{
 1509         -
    fn from(
 1510         -
        variant: crate::error::ValidationException,
 1511         -
    ) -> crate::error::MalformedTimestampBodyDateTimeError {
 1512         -
        Self::ValidationException(variant)
 1513         -
    }
 1514         -
}
 1515   1500   
impl ::std::convert::From<crate::error::InternalServerError>
 1516         -
    for crate::error::MalformedTimestampBodyDateTimeError
        1501  +
    for crate::error::HttpQueryParamsOnlyOperationError
 1517   1502   
{
 1518   1503   
    fn from(
 1519   1504   
        variant: crate::error::InternalServerError,
 1520         -
    ) -> crate::error::MalformedTimestampBodyDateTimeError {
        1505  +
    ) -> crate::error::HttpQueryParamsOnlyOperationError {
 1521   1506   
        Self::InternalServerError(variant)
 1522   1507   
    }
 1523   1508   
}
 1524   1509   
 1525         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampBodyDateTimeError {
 1526         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampBodyDateTimeError {
        1510  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpQueryParamsOnlyOperationError {
        1511  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpQueryParamsOnlyOperationError {
 1527   1512   
        ::pyo3::Python::with_gil(|py| {
 1528   1513   
            let error = variant.value(py);
 1529         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 1530         -
                return error.into();
 1531         -
            }
        1514  +
 1532   1515   
            crate::error::InternalServerError {
 1533   1516   
                message: error.to_string(),
 1534   1517   
            }
 1535   1518   
            .into()
 1536   1519   
        })
 1537   1520   
    }
 1538   1521   
}
 1539   1522   
 1540         -
/// Error type for the `MalformedTimestampBodyDefault` operation.
 1541         -
/// Each variant represents an error that can occur for the `MalformedTimestampBodyDefault` operation.
        1523  +
/// Error type for the `QueryParamsAsStringListMap` operation.
        1524  +
/// Each variant represents an error that can occur for the `QueryParamsAsStringListMap` operation.
 1542   1525   
#[derive(::std::fmt::Debug)]
 1543         -
pub enum MalformedTimestampBodyDefaultError {
 1544         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1545         -
    ValidationException(crate::error::ValidationException),
        1526  +
pub enum QueryParamsAsStringListMapError {
 1546   1527   
    #[allow(missing_docs)] // documentation missing in model
 1547   1528   
    InternalServerError(crate::error::InternalServerError),
 1548   1529   
}
 1549         -
impl ::std::fmt::Display for MalformedTimestampBodyDefaultError {
        1530  +
impl ::std::fmt::Display for QueryParamsAsStringListMapError {
 1550   1531   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1551   1532   
        match &self {
 1552         -
            MalformedTimestampBodyDefaultError::ValidationException(_inner) => _inner.fmt(f),
 1553         -
            MalformedTimestampBodyDefaultError::InternalServerError(_inner) => _inner.fmt(f),
        1533  +
            QueryParamsAsStringListMapError::InternalServerError(_inner) => _inner.fmt(f),
 1554   1534   
        }
 1555   1535   
    }
 1556   1536   
}
 1557         -
impl MalformedTimestampBodyDefaultError {
 1558         -
    /// Returns `true` if the error kind is `MalformedTimestampBodyDefaultError::ValidationException`.
 1559         -
    pub fn is_validation_exception(&self) -> bool {
 1560         -
        matches!(
 1561         -
            &self,
 1562         -
            MalformedTimestampBodyDefaultError::ValidationException(_)
 1563         -
        )
 1564         -
    }
 1565         -
    /// Returns `true` if the error kind is `MalformedTimestampBodyDefaultError::InternalServerError`.
        1537  +
impl QueryParamsAsStringListMapError {
        1538  +
    /// Returns `true` if the error kind is `QueryParamsAsStringListMapError::InternalServerError`.
 1566   1539   
    pub fn is_internal_server_error(&self) -> bool {
 1567   1540   
        matches!(
 1568   1541   
            &self,
 1569         -
            MalformedTimestampBodyDefaultError::InternalServerError(_)
        1542  +
            QueryParamsAsStringListMapError::InternalServerError(_)
 1570   1543   
        )
 1571   1544   
    }
 1572   1545   
    /// Returns the error name string by matching the correct variant.
 1573   1546   
    pub fn name(&self) -> &'static str {
 1574   1547   
        match &self {
 1575         -
            MalformedTimestampBodyDefaultError::ValidationException(_inner) => _inner.name(),
 1576         -
            MalformedTimestampBodyDefaultError::InternalServerError(_inner) => _inner.name(),
        1548  +
            QueryParamsAsStringListMapError::InternalServerError(_inner) => _inner.name(),
 1577   1549   
        }
 1578   1550   
    }
 1579   1551   
}
 1580         -
impl ::std::error::Error for MalformedTimestampBodyDefaultError {
        1552  +
impl ::std::error::Error for QueryParamsAsStringListMapError {
 1581   1553   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1582   1554   
        match &self {
 1583         -
            MalformedTimestampBodyDefaultError::ValidationException(_inner) => Some(_inner),
 1584         -
            MalformedTimestampBodyDefaultError::InternalServerError(_inner) => Some(_inner),
        1555  +
            QueryParamsAsStringListMapError::InternalServerError(_inner) => Some(_inner),
 1585   1556   
        }
 1586   1557   
    }
 1587   1558   
}
 1588         -
impl ::std::convert::From<crate::error::ValidationException>
 1589         -
    for crate::error::MalformedTimestampBodyDefaultError
 1590         -
{
 1591         -
    fn from(
 1592         -
        variant: crate::error::ValidationException,
 1593         -
    ) -> crate::error::MalformedTimestampBodyDefaultError {
 1594         -
        Self::ValidationException(variant)
 1595         -
    }
 1596         -
}
 1597   1559   
impl ::std::convert::From<crate::error::InternalServerError>
 1598         -
    for crate::error::MalformedTimestampBodyDefaultError
        1560  +
    for crate::error::QueryParamsAsStringListMapError
 1599   1561   
{
 1600   1562   
    fn from(
 1601   1563   
        variant: crate::error::InternalServerError,
 1602         -
    ) -> crate::error::MalformedTimestampBodyDefaultError {
        1564  +
    ) -> crate::error::QueryParamsAsStringListMapError {
 1603   1565   
        Self::InternalServerError(variant)
 1604   1566   
    }
 1605   1567   
}
 1606   1568   
 1607         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampBodyDefaultError {
 1608         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampBodyDefaultError {
        1569  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryParamsAsStringListMapError {
        1570  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::QueryParamsAsStringListMapError {
 1609   1571   
        ::pyo3::Python::with_gil(|py| {
 1610   1572   
            let error = variant.value(py);
 1611         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 1612         -
                return error.into();
 1613         -
            }
        1573  +
 1614   1574   
            crate::error::InternalServerError {
 1615   1575   
                message: error.to_string(),
 1616   1576   
            }
 1617   1577   
            .into()
 1618   1578   
        })
 1619   1579   
    }
 1620   1580   
}
 1621   1581   
 1622         -
/// Error type for the `MalformedTimestampHeaderEpoch` operation.
 1623         -
/// Each variant represents an error that can occur for the `MalformedTimestampHeaderEpoch` operation.
        1582  +
/// Error type for the `HttpPrefixHeaders` operation.
        1583  +
/// Each variant represents an error that can occur for the `HttpPrefixHeaders` operation.
 1624   1584   
#[derive(::std::fmt::Debug)]
 1625         -
pub enum MalformedTimestampHeaderEpochError {
 1626         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1627         -
    ValidationException(crate::error::ValidationException),
        1585  +
pub enum HttpPrefixHeadersError {
 1628   1586   
    #[allow(missing_docs)] // documentation missing in model
 1629   1587   
    InternalServerError(crate::error::InternalServerError),
 1630   1588   
}
 1631         -
impl ::std::fmt::Display for MalformedTimestampHeaderEpochError {
        1589  +
impl ::std::fmt::Display for HttpPrefixHeadersError {
 1632   1590   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1633   1591   
        match &self {
 1634         -
            MalformedTimestampHeaderEpochError::ValidationException(_inner) => _inner.fmt(f),
 1635         -
            MalformedTimestampHeaderEpochError::InternalServerError(_inner) => _inner.fmt(f),
        1592  +
            HttpPrefixHeadersError::InternalServerError(_inner) => _inner.fmt(f),
 1636   1593   
        }
 1637   1594   
    }
 1638   1595   
}
 1639         -
impl MalformedTimestampHeaderEpochError {
 1640         -
    /// Returns `true` if the error kind is `MalformedTimestampHeaderEpochError::ValidationException`.
 1641         -
    pub fn is_validation_exception(&self) -> bool {
 1642         -
        matches!(
 1643         -
            &self,
 1644         -
            MalformedTimestampHeaderEpochError::ValidationException(_)
 1645         -
        )
 1646         -
    }
 1647         -
    /// Returns `true` if the error kind is `MalformedTimestampHeaderEpochError::InternalServerError`.
        1596  +
impl HttpPrefixHeadersError {
        1597  +
    /// Returns `true` if the error kind is `HttpPrefixHeadersError::InternalServerError`.
 1648   1598   
    pub fn is_internal_server_error(&self) -> bool {
 1649         -
        matches!(
 1650         -
            &self,
 1651         -
            MalformedTimestampHeaderEpochError::InternalServerError(_)
 1652         -
        )
        1599  +
        matches!(&self, HttpPrefixHeadersError::InternalServerError(_))
 1653   1600   
    }
 1654   1601   
    /// Returns the error name string by matching the correct variant.
 1655   1602   
    pub fn name(&self) -> &'static str {
 1656   1603   
        match &self {
 1657         -
            MalformedTimestampHeaderEpochError::ValidationException(_inner) => _inner.name(),
 1658         -
            MalformedTimestampHeaderEpochError::InternalServerError(_inner) => _inner.name(),
        1604  +
            HttpPrefixHeadersError::InternalServerError(_inner) => _inner.name(),
 1659   1605   
        }
 1660   1606   
    }
 1661   1607   
}
 1662         -
impl ::std::error::Error for MalformedTimestampHeaderEpochError {
        1608  +
impl ::std::error::Error for HttpPrefixHeadersError {
 1663   1609   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1664   1610   
        match &self {
 1665         -
            MalformedTimestampHeaderEpochError::ValidationException(_inner) => Some(_inner),
 1666         -
            MalformedTimestampHeaderEpochError::InternalServerError(_inner) => Some(_inner),
        1611  +
            HttpPrefixHeadersError::InternalServerError(_inner) => Some(_inner),
 1667   1612   
        }
 1668   1613   
    }
 1669   1614   
}
 1670         -
impl ::std::convert::From<crate::error::ValidationException>
 1671         -
    for crate::error::MalformedTimestampHeaderEpochError
 1672         -
{
 1673         -
    fn from(
 1674         -
        variant: crate::error::ValidationException,
 1675         -
    ) -> crate::error::MalformedTimestampHeaderEpochError {
 1676         -
        Self::ValidationException(variant)
 1677         -
    }
 1678         -
}
 1679   1615   
impl ::std::convert::From<crate::error::InternalServerError>
 1680         -
    for crate::error::MalformedTimestampHeaderEpochError
        1616  +
    for crate::error::HttpPrefixHeadersError
 1681   1617   
{
 1682         -
    fn from(
 1683         -
        variant: crate::error::InternalServerError,
 1684         -
    ) -> crate::error::MalformedTimestampHeaderEpochError {
        1618  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpPrefixHeadersError {
 1685   1619   
        Self::InternalServerError(variant)
 1686   1620   
    }
 1687   1621   
}
 1688   1622   
 1689         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampHeaderEpochError {
 1690         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampHeaderEpochError {
        1623  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPrefixHeadersError {
        1624  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPrefixHeadersError {
 1691   1625   
        ::pyo3::Python::with_gil(|py| {
 1692   1626   
            let error = variant.value(py);
 1693         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 1694         -
                return error.into();
 1695         -
            }
        1627  +
 1696   1628   
            crate::error::InternalServerError {
 1697   1629   
                message: error.to_string(),
 1698   1630   
            }
 1699   1631   
            .into()
 1700   1632   
        })
 1701   1633   
    }
 1702   1634   
}
 1703   1635   
 1704         -
/// Error type for the `MalformedTimestampHeaderDateTime` operation.
 1705         -
/// Each variant represents an error that can occur for the `MalformedTimestampHeaderDateTime` operation.
        1636  +
/// Error type for the `HttpPrefixHeadersInResponse` operation.
        1637  +
/// Each variant represents an error that can occur for the `HttpPrefixHeadersInResponse` operation.
 1706   1638   
#[derive(::std::fmt::Debug)]
 1707         -
pub enum MalformedTimestampHeaderDateTimeError {
 1708         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1709         -
    ValidationException(crate::error::ValidationException),
        1639  +
pub enum HttpPrefixHeadersInResponseError {
 1710   1640   
    #[allow(missing_docs)] // documentation missing in model
 1711   1641   
    InternalServerError(crate::error::InternalServerError),
 1712   1642   
}
 1713         -
impl ::std::fmt::Display for MalformedTimestampHeaderDateTimeError {
        1643  +
impl ::std::fmt::Display for HttpPrefixHeadersInResponseError {
 1714   1644   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1715   1645   
        match &self {
 1716         -
            MalformedTimestampHeaderDateTimeError::ValidationException(_inner) => _inner.fmt(f),
 1717         -
            MalformedTimestampHeaderDateTimeError::InternalServerError(_inner) => _inner.fmt(f),
        1646  +
            HttpPrefixHeadersInResponseError::InternalServerError(_inner) => _inner.fmt(f),
 1718   1647   
        }
 1719   1648   
    }
 1720   1649   
}
 1721         -
impl MalformedTimestampHeaderDateTimeError {
 1722         -
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDateTimeError::ValidationException`.
 1723         -
    pub fn is_validation_exception(&self) -> bool {
 1724         -
        matches!(
 1725         -
            &self,
 1726         -
            MalformedTimestampHeaderDateTimeError::ValidationException(_)
 1727         -
        )
 1728         -
    }
 1729         -
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDateTimeError::InternalServerError`.
        1650  +
impl HttpPrefixHeadersInResponseError {
        1651  +
    /// Returns `true` if the error kind is `HttpPrefixHeadersInResponseError::InternalServerError`.
 1730   1652   
    pub fn is_internal_server_error(&self) -> bool {
 1731   1653   
        matches!(
 1732   1654   
            &self,
 1733         -
            MalformedTimestampHeaderDateTimeError::InternalServerError(_)
        1655  +
            HttpPrefixHeadersInResponseError::InternalServerError(_)
 1734   1656   
        )
 1735   1657   
    }
 1736   1658   
    /// Returns the error name string by matching the correct variant.
 1737   1659   
    pub fn name(&self) -> &'static str {
 1738   1660   
        match &self {
 1739         -
            MalformedTimestampHeaderDateTimeError::ValidationException(_inner) => _inner.name(),
 1740         -
            MalformedTimestampHeaderDateTimeError::InternalServerError(_inner) => _inner.name(),
        1661  +
            HttpPrefixHeadersInResponseError::InternalServerError(_inner) => _inner.name(),
 1741   1662   
        }
 1742   1663   
    }
 1743   1664   
}
 1744         -
impl ::std::error::Error for MalformedTimestampHeaderDateTimeError {
        1665  +
impl ::std::error::Error for HttpPrefixHeadersInResponseError {
 1745   1666   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1746   1667   
        match &self {
 1747         -
            MalformedTimestampHeaderDateTimeError::ValidationException(_inner) => Some(_inner),
 1748         -
            MalformedTimestampHeaderDateTimeError::InternalServerError(_inner) => Some(_inner),
        1668  +
            HttpPrefixHeadersInResponseError::InternalServerError(_inner) => Some(_inner),
 1749   1669   
        }
 1750   1670   
    }
 1751   1671   
}
 1752         -
impl ::std::convert::From<crate::error::ValidationException>
 1753         -
    for crate::error::MalformedTimestampHeaderDateTimeError
 1754         -
{
 1755         -
    fn from(
 1756         -
        variant: crate::error::ValidationException,
 1757         -
    ) -> crate::error::MalformedTimestampHeaderDateTimeError {
 1758         -
        Self::ValidationException(variant)
 1759         -
    }
 1760         -
}
 1761   1672   
impl ::std::convert::From<crate::error::InternalServerError>
 1762         -
    for crate::error::MalformedTimestampHeaderDateTimeError
        1673  +
    for crate::error::HttpPrefixHeadersInResponseError
 1763   1674   
{
 1764   1675   
    fn from(
 1765   1676   
        variant: crate::error::InternalServerError,
 1766         -
    ) -> crate::error::MalformedTimestampHeaderDateTimeError {
        1677  +
    ) -> crate::error::HttpPrefixHeadersInResponseError {
 1767   1678   
        Self::InternalServerError(variant)
 1768   1679   
    }
 1769   1680   
}
 1770   1681   
 1771         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampHeaderDateTimeError {
 1772         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampHeaderDateTimeError {
        1682  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPrefixHeadersInResponseError {
        1683  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPrefixHeadersInResponseError {
 1773   1684   
        ::pyo3::Python::with_gil(|py| {
 1774   1685   
            let error = variant.value(py);
 1775         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 1776         -
                return error.into();
 1777         -
            }
        1686  +
 1778   1687   
            crate::error::InternalServerError {
 1779   1688   
                message: error.to_string(),
 1780   1689   
            }
 1781   1690   
            .into()
 1782   1691   
        })
 1783   1692   
    }
 1784   1693   
}
 1785   1694   
 1786         -
/// Error type for the `MalformedTimestampHeaderDefault` operation.
 1787         -
/// Each variant represents an error that can occur for the `MalformedTimestampHeaderDefault` operation.
        1695  +
/// Error type for the `HttpEmptyPrefixHeaders` operation.
        1696  +
/// Each variant represents an error that can occur for the `HttpEmptyPrefixHeaders` operation.
 1788   1697   
#[derive(::std::fmt::Debug)]
 1789         -
pub enum MalformedTimestampHeaderDefaultError {
 1790         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1791         -
    ValidationException(crate::error::ValidationException),
        1698  +
pub enum HttpEmptyPrefixHeadersError {
 1792   1699   
    #[allow(missing_docs)] // documentation missing in model
 1793   1700   
    InternalServerError(crate::error::InternalServerError),
 1794   1701   
}
 1795         -
impl ::std::fmt::Display for MalformedTimestampHeaderDefaultError {
        1702  +
impl ::std::fmt::Display for HttpEmptyPrefixHeadersError {
 1796   1703   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1797   1704   
        match &self {
 1798         -
            MalformedTimestampHeaderDefaultError::ValidationException(_inner) => _inner.fmt(f),
 1799         -
            MalformedTimestampHeaderDefaultError::InternalServerError(_inner) => _inner.fmt(f),
        1705  +
            HttpEmptyPrefixHeadersError::InternalServerError(_inner) => _inner.fmt(f),
 1800   1706   
        }
 1801   1707   
    }
 1802   1708   
}
 1803         -
impl MalformedTimestampHeaderDefaultError {
 1804         -
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDefaultError::ValidationException`.
 1805         -
    pub fn is_validation_exception(&self) -> bool {
 1806         -
        matches!(
 1807         -
            &self,
 1808         -
            MalformedTimestampHeaderDefaultError::ValidationException(_)
 1809         -
        )
 1810         -
    }
 1811         -
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDefaultError::InternalServerError`.
        1709  +
impl HttpEmptyPrefixHeadersError {
        1710  +
    /// Returns `true` if the error kind is `HttpEmptyPrefixHeadersError::InternalServerError`.
 1812   1711   
    pub fn is_internal_server_error(&self) -> bool {
 1813         -
        matches!(
 1814         -
            &self,
 1815         -
            MalformedTimestampHeaderDefaultError::InternalServerError(_)
 1816         -
        )
        1712  +
        matches!(&self, HttpEmptyPrefixHeadersError::InternalServerError(_))
 1817   1713   
    }
 1818   1714   
    /// Returns the error name string by matching the correct variant.
 1819   1715   
    pub fn name(&self) -> &'static str {
 1820   1716   
        match &self {
 1821         -
            MalformedTimestampHeaderDefaultError::ValidationException(_inner) => _inner.name(),
 1822         -
            MalformedTimestampHeaderDefaultError::InternalServerError(_inner) => _inner.name(),
        1717  +
            HttpEmptyPrefixHeadersError::InternalServerError(_inner) => _inner.name(),
 1823   1718   
        }
 1824   1719   
    }
 1825   1720   
}
 1826         -
impl ::std::error::Error for MalformedTimestampHeaderDefaultError {
        1721  +
impl ::std::error::Error for HttpEmptyPrefixHeadersError {
 1827   1722   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1828   1723   
        match &self {
 1829         -
            MalformedTimestampHeaderDefaultError::ValidationException(_inner) => Some(_inner),
 1830         -
            MalformedTimestampHeaderDefaultError::InternalServerError(_inner) => Some(_inner),
        1724  +
            HttpEmptyPrefixHeadersError::InternalServerError(_inner) => Some(_inner),
 1831   1725   
        }
 1832   1726   
    }
 1833   1727   
}
 1834         -
impl ::std::convert::From<crate::error::ValidationException>
 1835         -
    for crate::error::MalformedTimestampHeaderDefaultError
 1836         -
{
 1837         -
    fn from(
 1838         -
        variant: crate::error::ValidationException,
 1839         -
    ) -> crate::error::MalformedTimestampHeaderDefaultError {
 1840         -
        Self::ValidationException(variant)
 1841         -
    }
 1842         -
}
 1843   1728   
impl ::std::convert::From<crate::error::InternalServerError>
 1844         -
    for crate::error::MalformedTimestampHeaderDefaultError
        1729  +
    for crate::error::HttpEmptyPrefixHeadersError
 1845   1730   
{
 1846   1731   
    fn from(
 1847   1732   
        variant: crate::error::InternalServerError,
 1848         -
    ) -> crate::error::MalformedTimestampHeaderDefaultError {
        1733  +
    ) -> crate::error::HttpEmptyPrefixHeadersError {
 1849   1734   
        Self::InternalServerError(variant)
 1850   1735   
    }
 1851   1736   
}
 1852   1737   
 1853         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampHeaderDefaultError {
 1854         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampHeaderDefaultError {
        1738  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpEmptyPrefixHeadersError {
        1739  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpEmptyPrefixHeadersError {
 1855   1740   
        ::pyo3::Python::with_gil(|py| {
 1856   1741   
            let error = variant.value(py);
 1857         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 1858         -
                return error.into();
 1859         -
            }
        1742  +
 1860   1743   
            crate::error::InternalServerError {
 1861   1744   
                message: error.to_string(),
 1862   1745   
            }
 1863   1746   
            .into()
 1864   1747   
        })
 1865   1748   
    }
 1866   1749   
}
 1867   1750   
 1868         -
/// Error type for the `MalformedTimestampQueryEpoch` operation.
 1869         -
/// Each variant represents an error that can occur for the `MalformedTimestampQueryEpoch` operation.
        1751  +
/// Error type for the `HttpPayloadTraits` operation.
        1752  +
/// Each variant represents an error that can occur for the `HttpPayloadTraits` operation.
 1870   1753   
#[derive(::std::fmt::Debug)]
 1871         -
pub enum MalformedTimestampQueryEpochError {
 1872         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1873         -
    ValidationException(crate::error::ValidationException),
        1754  +
pub enum HttpPayloadTraitsError {
 1874   1755   
    #[allow(missing_docs)] // documentation missing in model
 1875   1756   
    InternalServerError(crate::error::InternalServerError),
 1876   1757   
}
 1877         -
impl ::std::fmt::Display for MalformedTimestampQueryEpochError {
        1758  +
impl ::std::fmt::Display for HttpPayloadTraitsError {
 1878   1759   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1879   1760   
        match &self {
 1880         -
            MalformedTimestampQueryEpochError::ValidationException(_inner) => _inner.fmt(f),
 1881         -
            MalformedTimestampQueryEpochError::InternalServerError(_inner) => _inner.fmt(f),
        1761  +
            HttpPayloadTraitsError::InternalServerError(_inner) => _inner.fmt(f),
 1882   1762   
        }
 1883   1763   
    }
 1884   1764   
}
 1885         -
impl MalformedTimestampQueryEpochError {
 1886         -
    /// Returns `true` if the error kind is `MalformedTimestampQueryEpochError::ValidationException`.
 1887         -
    pub fn is_validation_exception(&self) -> bool {
 1888         -
        matches!(
 1889         -
            &self,
 1890         -
            MalformedTimestampQueryEpochError::ValidationException(_)
 1891         -
        )
 1892         -
    }
 1893         -
    /// Returns `true` if the error kind is `MalformedTimestampQueryEpochError::InternalServerError`.
        1765  +
impl HttpPayloadTraitsError {
        1766  +
    /// Returns `true` if the error kind is `HttpPayloadTraitsError::InternalServerError`.
 1894   1767   
    pub fn is_internal_server_error(&self) -> bool {
 1895         -
        matches!(
 1896         -
            &self,
 1897         -
            MalformedTimestampQueryEpochError::InternalServerError(_)
 1898         -
        )
        1768  +
        matches!(&self, HttpPayloadTraitsError::InternalServerError(_))
 1899   1769   
    }
 1900   1770   
    /// Returns the error name string by matching the correct variant.
 1901   1771   
    pub fn name(&self) -> &'static str {
 1902   1772   
        match &self {
 1903         -
            MalformedTimestampQueryEpochError::ValidationException(_inner) => _inner.name(),
 1904         -
            MalformedTimestampQueryEpochError::InternalServerError(_inner) => _inner.name(),
        1773  +
            HttpPayloadTraitsError::InternalServerError(_inner) => _inner.name(),
 1905   1774   
        }
 1906   1775   
    }
 1907   1776   
}
 1908         -
impl ::std::error::Error for MalformedTimestampQueryEpochError {
        1777  +
impl ::std::error::Error for HttpPayloadTraitsError {
 1909   1778   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1910   1779   
        match &self {
 1911         -
            MalformedTimestampQueryEpochError::ValidationException(_inner) => Some(_inner),
 1912         -
            MalformedTimestampQueryEpochError::InternalServerError(_inner) => Some(_inner),
        1780  +
            HttpPayloadTraitsError::InternalServerError(_inner) => Some(_inner),
 1913   1781   
        }
 1914   1782   
    }
 1915   1783   
}
 1916         -
impl ::std::convert::From<crate::error::ValidationException>
 1917         -
    for crate::error::MalformedTimestampQueryEpochError
 1918         -
{
 1919         -
    fn from(
 1920         -
        variant: crate::error::ValidationException,
 1921         -
    ) -> crate::error::MalformedTimestampQueryEpochError {
 1922         -
        Self::ValidationException(variant)
 1923         -
    }
 1924         -
}
 1925   1784   
impl ::std::convert::From<crate::error::InternalServerError>
 1926         -
    for crate::error::MalformedTimestampQueryEpochError
        1785  +
    for crate::error::HttpPayloadTraitsError
 1927   1786   
{
 1928         -
    fn from(
 1929         -
        variant: crate::error::InternalServerError,
 1930         -
    ) -> crate::error::MalformedTimestampQueryEpochError {
        1787  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpPayloadTraitsError {
 1931   1788   
        Self::InternalServerError(variant)
 1932   1789   
    }
 1933   1790   
}
 1934   1791   
 1935         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampQueryEpochError {
 1936         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampQueryEpochError {
        1792  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadTraitsError {
        1793  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadTraitsError {
 1937   1794   
        ::pyo3::Python::with_gil(|py| {
 1938   1795   
            let error = variant.value(py);
 1939         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 1940         -
                return error.into();
 1941         -
            }
        1796  +
 1942   1797   
            crate::error::InternalServerError {
 1943   1798   
                message: error.to_string(),
 1944   1799   
            }
 1945   1800   
            .into()
 1946   1801   
        })
 1947   1802   
    }
 1948   1803   
}
 1949   1804   
 1950         -
/// Error type for the `MalformedTimestampQueryHttpDate` operation.
 1951         -
/// Each variant represents an error that can occur for the `MalformedTimestampQueryHttpDate` operation.
        1805  +
/// Error type for the `HttpPayloadTraitsWithMediaType` operation.
        1806  +
/// Each variant represents an error that can occur for the `HttpPayloadTraitsWithMediaType` operation.
 1952   1807   
#[derive(::std::fmt::Debug)]
 1953         -
pub enum MalformedTimestampQueryHttpDateError {
 1954         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 1955         -
    ValidationException(crate::error::ValidationException),
        1808  +
pub enum HttpPayloadTraitsWithMediaTypeError {
 1956   1809   
    #[allow(missing_docs)] // documentation missing in model
 1957   1810   
    InternalServerError(crate::error::InternalServerError),
 1958   1811   
}
 1959         -
impl ::std::fmt::Display for MalformedTimestampQueryHttpDateError {
        1812  +
impl ::std::fmt::Display for HttpPayloadTraitsWithMediaTypeError {
 1960   1813   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 1961   1814   
        match &self {
 1962         -
            MalformedTimestampQueryHttpDateError::ValidationException(_inner) => _inner.fmt(f),
 1963         -
            MalformedTimestampQueryHttpDateError::InternalServerError(_inner) => _inner.fmt(f),
        1815  +
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.fmt(f),
 1964   1816   
        }
 1965   1817   
    }
 1966   1818   
}
 1967         -
impl MalformedTimestampQueryHttpDateError {
 1968         -
    /// Returns `true` if the error kind is `MalformedTimestampQueryHttpDateError::ValidationException`.
 1969         -
    pub fn is_validation_exception(&self) -> bool {
 1970         -
        matches!(
 1971         -
            &self,
 1972         -
            MalformedTimestampQueryHttpDateError::ValidationException(_)
 1973         -
        )
 1974         -
    }
 1975         -
    /// Returns `true` if the error kind is `MalformedTimestampQueryHttpDateError::InternalServerError`.
        1819  +
impl HttpPayloadTraitsWithMediaTypeError {
        1820  +
    /// Returns `true` if the error kind is `HttpPayloadTraitsWithMediaTypeError::InternalServerError`.
 1976   1821   
    pub fn is_internal_server_error(&self) -> bool {
 1977   1822   
        matches!(
 1978   1823   
            &self,
 1979         -
            MalformedTimestampQueryHttpDateError::InternalServerError(_)
        1824  +
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_)
 1980   1825   
        )
 1981   1826   
    }
 1982   1827   
    /// Returns the error name string by matching the correct variant.
 1983   1828   
    pub fn name(&self) -> &'static str {
 1984   1829   
        match &self {
 1985         -
            MalformedTimestampQueryHttpDateError::ValidationException(_inner) => _inner.name(),
 1986         -
            MalformedTimestampQueryHttpDateError::InternalServerError(_inner) => _inner.name(),
        1830  +
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.name(),
 1987   1831   
        }
 1988   1832   
    }
 1989   1833   
}
 1990         -
impl ::std::error::Error for MalformedTimestampQueryHttpDateError {
        1834  +
impl ::std::error::Error for HttpPayloadTraitsWithMediaTypeError {
 1991   1835   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 1992   1836   
        match &self {
 1993         -
            MalformedTimestampQueryHttpDateError::ValidationException(_inner) => Some(_inner),
 1994         -
            MalformedTimestampQueryHttpDateError::InternalServerError(_inner) => Some(_inner),
        1837  +
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_inner) => Some(_inner),
 1995   1838   
        }
 1996   1839   
    }
 1997   1840   
}
 1998         -
impl ::std::convert::From<crate::error::ValidationException>
 1999         -
    for crate::error::MalformedTimestampQueryHttpDateError
        1841  +
impl ::std::convert::From<crate::error::InternalServerError>
        1842  +
    for crate::error::HttpPayloadTraitsWithMediaTypeError
 2000   1843   
{
 2001   1844   
    fn from(
 2002         -
        variant: crate::error::ValidationException,
 2003         -
    ) -> crate::error::MalformedTimestampQueryHttpDateError {
 2004         -
        Self::ValidationException(variant)
 2005         -
    }
 2006         -
}
 2007         -
impl ::std::convert::From<crate::error::InternalServerError>
 2008         -
    for crate::error::MalformedTimestampQueryHttpDateError
 2009         -
{
 2010         -
    fn from(
 2011         -
        variant: crate::error::InternalServerError,
 2012         -
    ) -> crate::error::MalformedTimestampQueryHttpDateError {
 2013         -
        Self::InternalServerError(variant)
        1845  +
        variant: crate::error::InternalServerError,
        1846  +
    ) -> crate::error::HttpPayloadTraitsWithMediaTypeError {
        1847  +
        Self::InternalServerError(variant)
 2014   1848   
    }
 2015   1849   
}
 2016   1850   
 2017         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampQueryHttpDateError {
 2018         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampQueryHttpDateError {
        1851  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadTraitsWithMediaTypeError {
        1852  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadTraitsWithMediaTypeError {
 2019   1853   
        ::pyo3::Python::with_gil(|py| {
 2020   1854   
            let error = variant.value(py);
 2021         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2022         -
                return error.into();
 2023         -
            }
        1855  +
 2024   1856   
            crate::error::InternalServerError {
 2025   1857   
                message: error.to_string(),
 2026   1858   
            }
 2027   1859   
            .into()
 2028   1860   
        })
 2029   1861   
    }
 2030   1862   
}
 2031   1863   
 2032         -
/// Error type for the `MalformedTimestampQueryDefault` operation.
 2033         -
/// Each variant represents an error that can occur for the `MalformedTimestampQueryDefault` operation.
        1864  +
/// Error type for the `HttpPayloadWithStructure` operation.
        1865  +
/// Each variant represents an error that can occur for the `HttpPayloadWithStructure` operation.
 2034   1866   
#[derive(::std::fmt::Debug)]
 2035         -
pub enum MalformedTimestampQueryDefaultError {
 2036         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2037         -
    ValidationException(crate::error::ValidationException),
        1867  +
pub enum HttpPayloadWithStructureError {
 2038   1868   
    #[allow(missing_docs)] // documentation missing in model
 2039   1869   
    InternalServerError(crate::error::InternalServerError),
 2040   1870   
}
 2041         -
impl ::std::fmt::Display for MalformedTimestampQueryDefaultError {
        1871  +
impl ::std::fmt::Display for HttpPayloadWithStructureError {
 2042   1872   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2043   1873   
        match &self {
 2044         -
            MalformedTimestampQueryDefaultError::ValidationException(_inner) => _inner.fmt(f),
 2045         -
            MalformedTimestampQueryDefaultError::InternalServerError(_inner) => _inner.fmt(f),
        1874  +
            HttpPayloadWithStructureError::InternalServerError(_inner) => _inner.fmt(f),
 2046   1875   
        }
 2047   1876   
    }
 2048   1877   
}
 2049         -
impl MalformedTimestampQueryDefaultError {
 2050         -
    /// Returns `true` if the error kind is `MalformedTimestampQueryDefaultError::ValidationException`.
 2051         -
    pub fn is_validation_exception(&self) -> bool {
 2052         -
        matches!(
 2053         -
            &self,
 2054         -
            MalformedTimestampQueryDefaultError::ValidationException(_)
 2055         -
        )
 2056         -
    }
 2057         -
    /// Returns `true` if the error kind is `MalformedTimestampQueryDefaultError::InternalServerError`.
        1878  +
impl HttpPayloadWithStructureError {
        1879  +
    /// Returns `true` if the error kind is `HttpPayloadWithStructureError::InternalServerError`.
 2058   1880   
    pub fn is_internal_server_error(&self) -> bool {
 2059         -
        matches!(
 2060         -
            &self,
 2061         -
            MalformedTimestampQueryDefaultError::InternalServerError(_)
 2062         -
        )
        1881  +
        matches!(&self, HttpPayloadWithStructureError::InternalServerError(_))
 2063   1882   
    }
 2064   1883   
    /// Returns the error name string by matching the correct variant.
 2065   1884   
    pub fn name(&self) -> &'static str {
 2066   1885   
        match &self {
 2067         -
            MalformedTimestampQueryDefaultError::ValidationException(_inner) => _inner.name(),
 2068         -
            MalformedTimestampQueryDefaultError::InternalServerError(_inner) => _inner.name(),
        1886  +
            HttpPayloadWithStructureError::InternalServerError(_inner) => _inner.name(),
 2069   1887   
        }
 2070   1888   
    }
 2071   1889   
}
 2072         -
impl ::std::error::Error for MalformedTimestampQueryDefaultError {
        1890  +
impl ::std::error::Error for HttpPayloadWithStructureError {
 2073   1891   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2074   1892   
        match &self {
 2075         -
            MalformedTimestampQueryDefaultError::ValidationException(_inner) => Some(_inner),
 2076         -
            MalformedTimestampQueryDefaultError::InternalServerError(_inner) => Some(_inner),
        1893  +
            HttpPayloadWithStructureError::InternalServerError(_inner) => Some(_inner),
 2077   1894   
        }
 2078   1895   
    }
 2079   1896   
}
 2080         -
impl ::std::convert::From<crate::error::ValidationException>
 2081         -
    for crate::error::MalformedTimestampQueryDefaultError
 2082         -
{
 2083         -
    fn from(
 2084         -
        variant: crate::error::ValidationException,
 2085         -
    ) -> crate::error::MalformedTimestampQueryDefaultError {
 2086         -
        Self::ValidationException(variant)
 2087         -
    }
 2088         -
}
 2089   1897   
impl ::std::convert::From<crate::error::InternalServerError>
 2090         -
    for crate::error::MalformedTimestampQueryDefaultError
        1898  +
    for crate::error::HttpPayloadWithStructureError
 2091   1899   
{
 2092   1900   
    fn from(
 2093   1901   
        variant: crate::error::InternalServerError,
 2094         -
    ) -> crate::error::MalformedTimestampQueryDefaultError {
        1902  +
    ) -> crate::error::HttpPayloadWithStructureError {
 2095   1903   
        Self::InternalServerError(variant)
 2096   1904   
    }
 2097   1905   
}
 2098   1906   
 2099         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampQueryDefaultError {
 2100         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampQueryDefaultError {
        1907  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadWithStructureError {
        1908  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadWithStructureError {
 2101   1909   
        ::pyo3::Python::with_gil(|py| {
 2102   1910   
            let error = variant.value(py);
 2103         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2104         -
                return error.into();
 2105         -
            }
        1911  +
 2106   1912   
            crate::error::InternalServerError {
 2107   1913   
                message: error.to_string(),
 2108   1914   
            }
 2109   1915   
            .into()
 2110   1916   
        })
 2111   1917   
    }
 2112   1918   
}
 2113   1919   
 2114         -
/// Error type for the `MalformedTimestampPathEpoch` operation.
 2115         -
/// Each variant represents an error that can occur for the `MalformedTimestampPathEpoch` operation.
        1920  +
/// Error type for the `HttpEnumPayload` operation.
        1921  +
/// Each variant represents an error that can occur for the `HttpEnumPayload` operation.
 2116   1922   
#[derive(::std::fmt::Debug)]
 2117         -
pub enum MalformedTimestampPathEpochError {
        1923  +
pub enum HttpEnumPayloadError {
 2118   1924   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2119   1925   
    ValidationException(crate::error::ValidationException),
 2120   1926   
    #[allow(missing_docs)] // documentation missing in model
 2121   1927   
    InternalServerError(crate::error::InternalServerError),
 2122   1928   
}
 2123         -
impl ::std::fmt::Display for MalformedTimestampPathEpochError {
        1929  +
impl ::std::fmt::Display for HttpEnumPayloadError {
 2124   1930   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2125   1931   
        match &self {
 2126         -
            MalformedTimestampPathEpochError::ValidationException(_inner) => _inner.fmt(f),
 2127         -
            MalformedTimestampPathEpochError::InternalServerError(_inner) => _inner.fmt(f),
        1932  +
            HttpEnumPayloadError::ValidationException(_inner) => _inner.fmt(f),
        1933  +
            HttpEnumPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 2128   1934   
        }
 2129   1935   
    }
 2130   1936   
}
 2131         -
impl MalformedTimestampPathEpochError {
 2132         -
    /// Returns `true` if the error kind is `MalformedTimestampPathEpochError::ValidationException`.
        1937  +
impl HttpEnumPayloadError {
        1938  +
    /// Returns `true` if the error kind is `HttpEnumPayloadError::ValidationException`.
 2133   1939   
    pub fn is_validation_exception(&self) -> bool {
 2134         -
        matches!(
 2135         -
            &self,
 2136         -
            MalformedTimestampPathEpochError::ValidationException(_)
 2137         -
        )
        1940  +
        matches!(&self, HttpEnumPayloadError::ValidationException(_))
 2138   1941   
    }
 2139         -
    /// Returns `true` if the error kind is `MalformedTimestampPathEpochError::InternalServerError`.
        1942  +
    /// Returns `true` if the error kind is `HttpEnumPayloadError::InternalServerError`.
 2140   1943   
    pub fn is_internal_server_error(&self) -> bool {
 2141         -
        matches!(
 2142         -
            &self,
 2143         -
            MalformedTimestampPathEpochError::InternalServerError(_)
 2144         -
        )
        1944  +
        matches!(&self, HttpEnumPayloadError::InternalServerError(_))
 2145   1945   
    }
 2146   1946   
    /// Returns the error name string by matching the correct variant.
 2147   1947   
    pub fn name(&self) -> &'static str {
 2148   1948   
        match &self {
 2149         -
            MalformedTimestampPathEpochError::ValidationException(_inner) => _inner.name(),
 2150         -
            MalformedTimestampPathEpochError::InternalServerError(_inner) => _inner.name(),
        1949  +
            HttpEnumPayloadError::ValidationException(_inner) => _inner.name(),
        1950  +
            HttpEnumPayloadError::InternalServerError(_inner) => _inner.name(),
 2151   1951   
        }
 2152   1952   
    }
 2153   1953   
}
 2154         -
impl ::std::error::Error for MalformedTimestampPathEpochError {
        1954  +
impl ::std::error::Error for HttpEnumPayloadError {
 2155   1955   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2156   1956   
        match &self {
 2157         -
            MalformedTimestampPathEpochError::ValidationException(_inner) => Some(_inner),
 2158         -
            MalformedTimestampPathEpochError::InternalServerError(_inner) => Some(_inner),
        1957  +
            HttpEnumPayloadError::ValidationException(_inner) => Some(_inner),
        1958  +
            HttpEnumPayloadError::InternalServerError(_inner) => Some(_inner),
 2159   1959   
        }
 2160   1960   
    }
 2161   1961   
}
 2162   1962   
impl ::std::convert::From<crate::error::ValidationException>
 2163         -
    for crate::error::MalformedTimestampPathEpochError
        1963  +
    for crate::error::HttpEnumPayloadError
 2164   1964   
{
 2165         -
    fn from(
 2166         -
        variant: crate::error::ValidationException,
 2167         -
    ) -> crate::error::MalformedTimestampPathEpochError {
        1965  +
    fn from(variant: crate::error::ValidationException) -> crate::error::HttpEnumPayloadError {
 2168   1966   
        Self::ValidationException(variant)
 2169   1967   
    }
 2170   1968   
}
 2171   1969   
impl ::std::convert::From<crate::error::InternalServerError>
 2172         -
    for crate::error::MalformedTimestampPathEpochError
        1970  +
    for crate::error::HttpEnumPayloadError
 2173   1971   
{
 2174         -
    fn from(
 2175         -
        variant: crate::error::InternalServerError,
 2176         -
    ) -> crate::error::MalformedTimestampPathEpochError {
        1972  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpEnumPayloadError {
 2177   1973   
        Self::InternalServerError(variant)
 2178   1974   
    }
 2179   1975   
}
 2180   1976   
 2181         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampPathEpochError {
 2182         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampPathEpochError {
        1977  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpEnumPayloadError {
        1978  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpEnumPayloadError {
 2183   1979   
        ::pyo3::Python::with_gil(|py| {
 2184   1980   
            let error = variant.value(py);
 2185   1981   
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2186   1982   
                return error.into();
 2187   1983   
            }
 2188   1984   
            crate::error::InternalServerError {
 2189   1985   
                message: error.to_string(),
 2190   1986   
            }
 2191   1987   
            .into()
 2192   1988   
        })
 2193   1989   
    }
 2194   1990   
}
 2195   1991   
 2196         -
/// Error type for the `MalformedTimestampPathHttpDate` operation.
 2197         -
/// Each variant represents an error that can occur for the `MalformedTimestampPathHttpDate` operation.
        1992  +
/// Error type for the `HttpStringPayload` operation.
        1993  +
/// Each variant represents an error that can occur for the `HttpStringPayload` operation.
 2198   1994   
#[derive(::std::fmt::Debug)]
 2199         -
pub enum MalformedTimestampPathHttpDateError {
 2200         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2201         -
    ValidationException(crate::error::ValidationException),
        1995  +
pub enum HttpStringPayloadError {
 2202   1996   
    #[allow(missing_docs)] // documentation missing in model
 2203   1997   
    InternalServerError(crate::error::InternalServerError),
 2204   1998   
}
 2205         -
impl ::std::fmt::Display for MalformedTimestampPathHttpDateError {
        1999  +
impl ::std::fmt::Display for HttpStringPayloadError {
 2206   2000   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2207   2001   
        match &self {
 2208         -
            MalformedTimestampPathHttpDateError::ValidationException(_inner) => _inner.fmt(f),
 2209         -
            MalformedTimestampPathHttpDateError::InternalServerError(_inner) => _inner.fmt(f),
        2002  +
            HttpStringPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 2210   2003   
        }
 2211   2004   
    }
 2212   2005   
}
 2213         -
impl MalformedTimestampPathHttpDateError {
 2214         -
    /// Returns `true` if the error kind is `MalformedTimestampPathHttpDateError::ValidationException`.
 2215         -
    pub fn is_validation_exception(&self) -> bool {
 2216         -
        matches!(
 2217         -
            &self,
 2218         -
            MalformedTimestampPathHttpDateError::ValidationException(_)
 2219         -
        )
 2220         -
    }
 2221         -
    /// Returns `true` if the error kind is `MalformedTimestampPathHttpDateError::InternalServerError`.
        2006  +
impl HttpStringPayloadError {
        2007  +
    /// Returns `true` if the error kind is `HttpStringPayloadError::InternalServerError`.
 2222   2008   
    pub fn is_internal_server_error(&self) -> bool {
 2223         -
        matches!(
 2224         -
            &self,
 2225         -
            MalformedTimestampPathHttpDateError::InternalServerError(_)
 2226         -
        )
        2009  +
        matches!(&self, HttpStringPayloadError::InternalServerError(_))
 2227   2010   
    }
 2228   2011   
    /// Returns the error name string by matching the correct variant.
 2229   2012   
    pub fn name(&self) -> &'static str {
 2230   2013   
        match &self {
 2231         -
            MalformedTimestampPathHttpDateError::ValidationException(_inner) => _inner.name(),
 2232         -
            MalformedTimestampPathHttpDateError::InternalServerError(_inner) => _inner.name(),
        2014  +
            HttpStringPayloadError::InternalServerError(_inner) => _inner.name(),
 2233   2015   
        }
 2234   2016   
    }
 2235   2017   
}
 2236         -
impl ::std::error::Error for MalformedTimestampPathHttpDateError {
        2018  +
impl ::std::error::Error for HttpStringPayloadError {
 2237   2019   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2238   2020   
        match &self {
 2239         -
            MalformedTimestampPathHttpDateError::ValidationException(_inner) => Some(_inner),
 2240         -
            MalformedTimestampPathHttpDateError::InternalServerError(_inner) => Some(_inner),
        2021  +
            HttpStringPayloadError::InternalServerError(_inner) => Some(_inner),
 2241   2022   
        }
 2242   2023   
    }
 2243   2024   
}
 2244         -
impl ::std::convert::From<crate::error::ValidationException>
 2245         -
    for crate::error::MalformedTimestampPathHttpDateError
 2246         -
{
 2247         -
    fn from(
 2248         -
        variant: crate::error::ValidationException,
 2249         -
    ) -> crate::error::MalformedTimestampPathHttpDateError {
 2250         -
        Self::ValidationException(variant)
 2251         -
    }
 2252         -
}
 2253   2025   
impl ::std::convert::From<crate::error::InternalServerError>
 2254         -
    for crate::error::MalformedTimestampPathHttpDateError
        2026  +
    for crate::error::HttpStringPayloadError
 2255   2027   
{
 2256         -
    fn from(
 2257         -
        variant: crate::error::InternalServerError,
 2258         -
    ) -> crate::error::MalformedTimestampPathHttpDateError {
        2028  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpStringPayloadError {
 2259   2029   
        Self::InternalServerError(variant)
 2260   2030   
    }
 2261   2031   
}
 2262   2032   
 2263         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampPathHttpDateError {
 2264         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampPathHttpDateError {
        2033  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpStringPayloadError {
        2034  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpStringPayloadError {
 2265   2035   
        ::pyo3::Python::with_gil(|py| {
 2266   2036   
            let error = variant.value(py);
 2267         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2268         -
                return error.into();
 2269         -
            }
        2037  +
 2270   2038   
            crate::error::InternalServerError {
 2271   2039   
                message: error.to_string(),
 2272   2040   
            }
 2273   2041   
            .into()
 2274   2042   
        })
 2275   2043   
    }
 2276   2044   
}
 2277   2045   
 2278         -
/// Error type for the `MalformedTimestampPathDefault` operation.
 2279         -
/// Each variant represents an error that can occur for the `MalformedTimestampPathDefault` operation.
        2046  +
/// Error type for the `HttpPayloadWithUnion` operation.
        2047  +
/// Each variant represents an error that can occur for the `HttpPayloadWithUnion` operation.
 2280   2048   
#[derive(::std::fmt::Debug)]
 2281         -
pub enum MalformedTimestampPathDefaultError {
 2282         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2283         -
    ValidationException(crate::error::ValidationException),
        2049  +
pub enum HttpPayloadWithUnionError {
 2284   2050   
    #[allow(missing_docs)] // documentation missing in model
 2285   2051   
    InternalServerError(crate::error::InternalServerError),
 2286   2052   
}
 2287         -
impl ::std::fmt::Display for MalformedTimestampPathDefaultError {
        2053  +
impl ::std::fmt::Display for HttpPayloadWithUnionError {
 2288   2054   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2289   2055   
        match &self {
 2290         -
            MalformedTimestampPathDefaultError::ValidationException(_inner) => _inner.fmt(f),
 2291         -
            MalformedTimestampPathDefaultError::InternalServerError(_inner) => _inner.fmt(f),
        2056  +
            HttpPayloadWithUnionError::InternalServerError(_inner) => _inner.fmt(f),
 2292   2057   
        }
 2293   2058   
    }
 2294   2059   
}
 2295         -
impl MalformedTimestampPathDefaultError {
 2296         -
    /// Returns `true` if the error kind is `MalformedTimestampPathDefaultError::ValidationException`.
 2297         -
    pub fn is_validation_exception(&self) -> bool {
 2298         -
        matches!(
 2299         -
            &self,
 2300         -
            MalformedTimestampPathDefaultError::ValidationException(_)
 2301         -
        )
 2302         -
    }
 2303         -
    /// Returns `true` if the error kind is `MalformedTimestampPathDefaultError::InternalServerError`.
        2060  +
impl HttpPayloadWithUnionError {
        2061  +
    /// Returns `true` if the error kind is `HttpPayloadWithUnionError::InternalServerError`.
 2304   2062   
    pub fn is_internal_server_error(&self) -> bool {
 2305         -
        matches!(
 2306         -
            &self,
 2307         -
            MalformedTimestampPathDefaultError::InternalServerError(_)
 2308         -
        )
        2063  +
        matches!(&self, HttpPayloadWithUnionError::InternalServerError(_))
 2309   2064   
    }
 2310   2065   
    /// Returns the error name string by matching the correct variant.
 2311   2066   
    pub fn name(&self) -> &'static str {
 2312   2067   
        match &self {
 2313         -
            MalformedTimestampPathDefaultError::ValidationException(_inner) => _inner.name(),
 2314         -
            MalformedTimestampPathDefaultError::InternalServerError(_inner) => _inner.name(),
        2068  +
            HttpPayloadWithUnionError::InternalServerError(_inner) => _inner.name(),
 2315   2069   
        }
 2316   2070   
    }
 2317   2071   
}
 2318         -
impl ::std::error::Error for MalformedTimestampPathDefaultError {
        2072  +
impl ::std::error::Error for HttpPayloadWithUnionError {
 2319   2073   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2320   2074   
        match &self {
 2321         -
            MalformedTimestampPathDefaultError::ValidationException(_inner) => Some(_inner),
 2322         -
            MalformedTimestampPathDefaultError::InternalServerError(_inner) => Some(_inner),
        2075  +
            HttpPayloadWithUnionError::InternalServerError(_inner) => Some(_inner),
 2323   2076   
        }
 2324   2077   
    }
 2325   2078   
}
 2326         -
impl ::std::convert::From<crate::error::ValidationException>
 2327         -
    for crate::error::MalformedTimestampPathDefaultError
 2328         -
{
 2329         -
    fn from(
 2330         -
        variant: crate::error::ValidationException,
 2331         -
    ) -> crate::error::MalformedTimestampPathDefaultError {
 2332         -
        Self::ValidationException(variant)
 2333         -
    }
 2334         -
}
 2335   2079   
impl ::std::convert::From<crate::error::InternalServerError>
 2336         -
    for crate::error::MalformedTimestampPathDefaultError
        2080  +
    for crate::error::HttpPayloadWithUnionError
 2337   2081   
{
 2338         -
    fn from(
 2339         -
        variant: crate::error::InternalServerError,
 2340         -
    ) -> crate::error::MalformedTimestampPathDefaultError {
        2082  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpPayloadWithUnionError {
 2341   2083   
        Self::InternalServerError(variant)
 2342   2084   
    }
 2343   2085   
}
 2344   2086   
 2345         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampPathDefaultError {
 2346         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampPathDefaultError {
        2087  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadWithUnionError {
        2088  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadWithUnionError {
 2347   2089   
        ::pyo3::Python::with_gil(|py| {
 2348   2090   
            let error = variant.value(py);
 2349         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2350         -
                return error.into();
 2351         -
            }
        2091  +
 2352   2092   
            crate::error::InternalServerError {
 2353   2093   
                message: error.to_string(),
 2354   2094   
            }
 2355   2095   
            .into()
 2356   2096   
        })
 2357   2097   
    }
 2358   2098   
}
 2359   2099   
 2360         -
/// Error type for the `MalformedString` operation.
 2361         -
/// Each variant represents an error that can occur for the `MalformedString` operation.
        2100  +
/// Error type for the `HttpResponseCode` operation.
        2101  +
/// Each variant represents an error that can occur for the `HttpResponseCode` operation.
 2362   2102   
#[derive(::std::fmt::Debug)]
 2363         -
pub enum MalformedStringError {
        2103  +
pub enum HttpResponseCodeError {
 2364   2104   
    #[allow(missing_docs)] // documentation missing in model
 2365   2105   
    InternalServerError(crate::error::InternalServerError),
 2366   2106   
}
 2367         -
impl ::std::fmt::Display for MalformedStringError {
        2107  +
impl ::std::fmt::Display for HttpResponseCodeError {
 2368   2108   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2369   2109   
        match &self {
 2370         -
            MalformedStringError::InternalServerError(_inner) => _inner.fmt(f),
        2110  +
            HttpResponseCodeError::InternalServerError(_inner) => _inner.fmt(f),
 2371   2111   
        }
 2372   2112   
    }
 2373   2113   
}
 2374         -
impl MalformedStringError {
 2375         -
    /// Returns `true` if the error kind is `MalformedStringError::InternalServerError`.
        2114  +
impl HttpResponseCodeError {
        2115  +
    /// Returns `true` if the error kind is `HttpResponseCodeError::InternalServerError`.
 2376   2116   
    pub fn is_internal_server_error(&self) -> bool {
 2377         -
        matches!(&self, MalformedStringError::InternalServerError(_))
        2117  +
        matches!(&self, HttpResponseCodeError::InternalServerError(_))
 2378   2118   
    }
 2379   2119   
    /// Returns the error name string by matching the correct variant.
 2380   2120   
    pub fn name(&self) -> &'static str {
 2381   2121   
        match &self {
 2382         -
            MalformedStringError::InternalServerError(_inner) => _inner.name(),
        2122  +
            HttpResponseCodeError::InternalServerError(_inner) => _inner.name(),
 2383   2123   
        }
 2384   2124   
    }
 2385   2125   
}
 2386         -
impl ::std::error::Error for MalformedStringError {
        2126  +
impl ::std::error::Error for HttpResponseCodeError {
 2387   2127   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2388   2128   
        match &self {
 2389         -
            MalformedStringError::InternalServerError(_inner) => Some(_inner),
        2129  +
            HttpResponseCodeError::InternalServerError(_inner) => Some(_inner),
 2390   2130   
        }
 2391   2131   
    }
 2392   2132   
}
 2393   2133   
impl ::std::convert::From<crate::error::InternalServerError>
 2394         -
    for crate::error::MalformedStringError
        2134  +
    for crate::error::HttpResponseCodeError
 2395   2135   
{
 2396         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedStringError {
        2136  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpResponseCodeError {
 2397   2137   
        Self::InternalServerError(variant)
 2398   2138   
    }
 2399   2139   
}
 2400   2140   
 2401         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedStringError {
 2402         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedStringError {
        2141  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpResponseCodeError {
        2142  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpResponseCodeError {
 2403   2143   
        ::pyo3::Python::with_gil(|py| {
 2404   2144   
            let error = variant.value(py);
 2405   2145   
 2406   2146   
            crate::error::InternalServerError {
 2407   2147   
                message: error.to_string(),
 2408   2148   
            }
 2409   2149   
            .into()
 2410   2150   
        })
 2411   2151   
    }
 2412   2152   
}
 2413   2153   
 2414         -
/// Error type for the `MalformedDouble` operation.
 2415         -
/// Each variant represents an error that can occur for the `MalformedDouble` operation.
        2154  +
/// Error type for the `ResponseCodeRequired` operation.
        2155  +
/// Each variant represents an error that can occur for the `ResponseCodeRequired` operation.
 2416   2156   
#[derive(::std::fmt::Debug)]
 2417         -
pub enum MalformedDoubleError {
 2418         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2419         -
    ValidationException(crate::error::ValidationException),
        2157  +
pub enum ResponseCodeRequiredError {
 2420   2158   
    #[allow(missing_docs)] // documentation missing in model
 2421   2159   
    InternalServerError(crate::error::InternalServerError),
 2422   2160   
}
 2423         -
impl ::std::fmt::Display for MalformedDoubleError {
        2161  +
impl ::std::fmt::Display for ResponseCodeRequiredError {
 2424   2162   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2425   2163   
        match &self {
 2426         -
            MalformedDoubleError::ValidationException(_inner) => _inner.fmt(f),
 2427         -
            MalformedDoubleError::InternalServerError(_inner) => _inner.fmt(f),
        2164  +
            ResponseCodeRequiredError::InternalServerError(_inner) => _inner.fmt(f),
 2428   2165   
        }
 2429   2166   
    }
 2430   2167   
}
 2431         -
impl MalformedDoubleError {
 2432         -
    /// Returns `true` if the error kind is `MalformedDoubleError::ValidationException`.
 2433         -
    pub fn is_validation_exception(&self) -> bool {
 2434         -
        matches!(&self, MalformedDoubleError::ValidationException(_))
 2435         -
    }
 2436         -
    /// Returns `true` if the error kind is `MalformedDoubleError::InternalServerError`.
        2168  +
impl ResponseCodeRequiredError {
        2169  +
    /// Returns `true` if the error kind is `ResponseCodeRequiredError::InternalServerError`.
 2437   2170   
    pub fn is_internal_server_error(&self) -> bool {
 2438         -
        matches!(&self, MalformedDoubleError::InternalServerError(_))
        2171  +
        matches!(&self, ResponseCodeRequiredError::InternalServerError(_))
 2439   2172   
    }
 2440   2173   
    /// Returns the error name string by matching the correct variant.
 2441   2174   
    pub fn name(&self) -> &'static str {
 2442   2175   
        match &self {
 2443         -
            MalformedDoubleError::ValidationException(_inner) => _inner.name(),
 2444         -
            MalformedDoubleError::InternalServerError(_inner) => _inner.name(),
        2176  +
            ResponseCodeRequiredError::InternalServerError(_inner) => _inner.name(),
 2445   2177   
        }
 2446   2178   
    }
 2447   2179   
}
 2448         -
impl ::std::error::Error for MalformedDoubleError {
        2180  +
impl ::std::error::Error for ResponseCodeRequiredError {
 2449   2181   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2450   2182   
        match &self {
 2451         -
            MalformedDoubleError::ValidationException(_inner) => Some(_inner),
 2452         -
            MalformedDoubleError::InternalServerError(_inner) => Some(_inner),
        2183  +
            ResponseCodeRequiredError::InternalServerError(_inner) => Some(_inner),
 2453   2184   
        }
 2454   2185   
    }
 2455   2186   
}
 2456         -
impl ::std::convert::From<crate::error::ValidationException>
 2457         -
    for crate::error::MalformedDoubleError
 2458         -
{
 2459         -
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedDoubleError {
 2460         -
        Self::ValidationException(variant)
 2461         -
    }
 2462         -
}
 2463   2187   
impl ::std::convert::From<crate::error::InternalServerError>
 2464         -
    for crate::error::MalformedDoubleError
        2188  +
    for crate::error::ResponseCodeRequiredError
 2465   2189   
{
 2466         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedDoubleError {
        2190  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::ResponseCodeRequiredError {
 2467   2191   
        Self::InternalServerError(variant)
 2468   2192   
    }
 2469   2193   
}
 2470   2194   
 2471         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedDoubleError {
 2472         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedDoubleError {
        2195  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeRequiredError {
        2196  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeRequiredError {
 2473   2197   
        ::pyo3::Python::with_gil(|py| {
 2474   2198   
            let error = variant.value(py);
 2475         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2476         -
                return error.into();
 2477         -
            }
        2199  +
 2478   2200   
            crate::error::InternalServerError {
 2479   2201   
                message: error.to_string(),
 2480   2202   
            }
 2481   2203   
            .into()
 2482   2204   
        })
 2483   2205   
    }
 2484   2206   
}
 2485   2207   
 2486         -
/// Error type for the `MalformedFloat` operation.
 2487         -
/// Each variant represents an error that can occur for the `MalformedFloat` operation.
        2208  +
/// Error type for the `ResponseCodeHttpFallback` operation.
        2209  +
/// Each variant represents an error that can occur for the `ResponseCodeHttpFallback` operation.
 2488   2210   
#[derive(::std::fmt::Debug)]
 2489         -
pub enum MalformedFloatError {
 2490         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2491         -
    ValidationException(crate::error::ValidationException),
        2211  +
pub enum ResponseCodeHttpFallbackError {
 2492   2212   
    #[allow(missing_docs)] // documentation missing in model
 2493   2213   
    InternalServerError(crate::error::InternalServerError),
 2494   2214   
}
 2495         -
impl ::std::fmt::Display for MalformedFloatError {
        2215  +
impl ::std::fmt::Display for ResponseCodeHttpFallbackError {
 2496   2216   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2497   2217   
        match &self {
 2498         -
            MalformedFloatError::ValidationException(_inner) => _inner.fmt(f),
 2499         -
            MalformedFloatError::InternalServerError(_inner) => _inner.fmt(f),
        2218  +
            ResponseCodeHttpFallbackError::InternalServerError(_inner) => _inner.fmt(f),
 2500   2219   
        }
 2501   2220   
    }
 2502   2221   
}
 2503         -
impl MalformedFloatError {
 2504         -
    /// Returns `true` if the error kind is `MalformedFloatError::ValidationException`.
 2505         -
    pub fn is_validation_exception(&self) -> bool {
 2506         -
        matches!(&self, MalformedFloatError::ValidationException(_))
 2507         -
    }
 2508         -
    /// Returns `true` if the error kind is `MalformedFloatError::InternalServerError`.
        2222  +
impl ResponseCodeHttpFallbackError {
        2223  +
    /// Returns `true` if the error kind is `ResponseCodeHttpFallbackError::InternalServerError`.
 2509   2224   
    pub fn is_internal_server_error(&self) -> bool {
 2510         -
        matches!(&self, MalformedFloatError::InternalServerError(_))
        2225  +
        matches!(&self, ResponseCodeHttpFallbackError::InternalServerError(_))
 2511   2226   
    }
 2512   2227   
    /// Returns the error name string by matching the correct variant.
 2513   2228   
    pub fn name(&self) -> &'static str {
 2514   2229   
        match &self {
 2515         -
            MalformedFloatError::ValidationException(_inner) => _inner.name(),
 2516         -
            MalformedFloatError::InternalServerError(_inner) => _inner.name(),
        2230  +
            ResponseCodeHttpFallbackError::InternalServerError(_inner) => _inner.name(),
 2517   2231   
        }
 2518   2232   
    }
 2519   2233   
}
 2520         -
impl ::std::error::Error for MalformedFloatError {
        2234  +
impl ::std::error::Error for ResponseCodeHttpFallbackError {
 2521   2235   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2522   2236   
        match &self {
 2523         -
            MalformedFloatError::ValidationException(_inner) => Some(_inner),
 2524         -
            MalformedFloatError::InternalServerError(_inner) => Some(_inner),
        2237  +
            ResponseCodeHttpFallbackError::InternalServerError(_inner) => Some(_inner),
 2525   2238   
        }
 2526   2239   
    }
 2527   2240   
}
 2528         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedFloatError {
 2529         -
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedFloatError {
 2530         -
        Self::ValidationException(variant)
 2531         -
    }
 2532         -
}
 2533         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedFloatError {
 2534         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedFloatError {
        2241  +
impl ::std::convert::From<crate::error::InternalServerError>
        2242  +
    for crate::error::ResponseCodeHttpFallbackError
        2243  +
{
        2244  +
    fn from(
        2245  +
        variant: crate::error::InternalServerError,
        2246  +
    ) -> crate::error::ResponseCodeHttpFallbackError {
 2535   2247   
        Self::InternalServerError(variant)
 2536   2248   
    }
 2537   2249   
}
 2538   2250   
 2539         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedFloatError {
 2540         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedFloatError {
        2251  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeHttpFallbackError {
        2252  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeHttpFallbackError {
 2541   2253   
        ::pyo3::Python::with_gil(|py| {
 2542   2254   
            let error = variant.value(py);
 2543         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2544         -
                return error.into();
 2545         -
            }
        2255  +
 2546   2256   
            crate::error::InternalServerError {
 2547   2257   
                message: error.to_string(),
 2548   2258   
            }
 2549   2259   
            .into()
 2550   2260   
        })
 2551   2261   
    }
 2552   2262   
}
 2553   2263   
 2554         -
/// Error type for the `MalformedLong` operation.
 2555         -
/// Each variant represents an error that can occur for the `MalformedLong` operation.
        2264  +
/// Error type for the `StreamingTraits` operation.
        2265  +
/// Each variant represents an error that can occur for the `StreamingTraits` operation.
 2556   2266   
#[derive(::std::fmt::Debug)]
 2557         -
pub enum MalformedLongError {
 2558         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2559         -
    ValidationException(crate::error::ValidationException),
        2267  +
pub enum StreamingTraitsError {
 2560   2268   
    #[allow(missing_docs)] // documentation missing in model
 2561   2269   
    InternalServerError(crate::error::InternalServerError),
 2562   2270   
}
 2563         -
impl ::std::fmt::Display for MalformedLongError {
        2271  +
impl ::std::fmt::Display for StreamingTraitsError {
 2564   2272   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2565   2273   
        match &self {
 2566         -
            MalformedLongError::ValidationException(_inner) => _inner.fmt(f),
 2567         -
            MalformedLongError::InternalServerError(_inner) => _inner.fmt(f),
        2274  +
            StreamingTraitsError::InternalServerError(_inner) => _inner.fmt(f),
 2568   2275   
        }
 2569   2276   
    }
 2570   2277   
}
 2571         -
impl MalformedLongError {
 2572         -
    /// Returns `true` if the error kind is `MalformedLongError::ValidationException`.
 2573         -
    pub fn is_validation_exception(&self) -> bool {
 2574         -
        matches!(&self, MalformedLongError::ValidationException(_))
 2575         -
    }
 2576         -
    /// Returns `true` if the error kind is `MalformedLongError::InternalServerError`.
        2278  +
impl StreamingTraitsError {
        2279  +
    /// Returns `true` if the error kind is `StreamingTraitsError::InternalServerError`.
 2577   2280   
    pub fn is_internal_server_error(&self) -> bool {
 2578         -
        matches!(&self, MalformedLongError::InternalServerError(_))
        2281  +
        matches!(&self, StreamingTraitsError::InternalServerError(_))
 2579   2282   
    }
 2580   2283   
    /// Returns the error name string by matching the correct variant.
 2581   2284   
    pub fn name(&self) -> &'static str {
 2582   2285   
        match &self {
 2583         -
            MalformedLongError::ValidationException(_inner) => _inner.name(),
 2584         -
            MalformedLongError::InternalServerError(_inner) => _inner.name(),
        2286  +
            StreamingTraitsError::InternalServerError(_inner) => _inner.name(),
 2585   2287   
        }
 2586   2288   
    }
 2587   2289   
}
 2588         -
impl ::std::error::Error for MalformedLongError {
        2290  +
impl ::std::error::Error for StreamingTraitsError {
 2589   2291   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2590   2292   
        match &self {
 2591         -
            MalformedLongError::ValidationException(_inner) => Some(_inner),
 2592         -
            MalformedLongError::InternalServerError(_inner) => Some(_inner),
        2293  +
            StreamingTraitsError::InternalServerError(_inner) => Some(_inner),
 2593   2294   
        }
 2594   2295   
    }
 2595   2296   
}
 2596         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedLongError {
 2597         -
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedLongError {
 2598         -
        Self::ValidationException(variant)
 2599         -
    }
 2600         -
}
 2601         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedLongError {
 2602         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedLongError {
        2297  +
impl ::std::convert::From<crate::error::InternalServerError>
        2298  +
    for crate::error::StreamingTraitsError
        2299  +
{
        2300  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::StreamingTraitsError {
 2603   2301   
        Self::InternalServerError(variant)
 2604   2302   
    }
 2605   2303   
}
 2606   2304   
 2607         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedLongError {
 2608         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedLongError {
        2305  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::StreamingTraitsError {
        2306  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::StreamingTraitsError {
 2609   2307   
        ::pyo3::Python::with_gil(|py| {
 2610   2308   
            let error = variant.value(py);
 2611         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2612         -
                return error.into();
 2613         -
            }
        2309  +
 2614   2310   
            crate::error::InternalServerError {
 2615   2311   
                message: error.to_string(),
 2616   2312   
            }
 2617   2313   
            .into()
 2618   2314   
        })
 2619   2315   
    }
 2620   2316   
}
 2621   2317   
 2622         -
/// Error type for the `MalformedShort` operation.
 2623         -
/// Each variant represents an error that can occur for the `MalformedShort` operation.
        2318  +
/// Error type for the `StreamingTraitsRequireLength` operation.
        2319  +
/// Each variant represents an error that can occur for the `StreamingTraitsRequireLength` operation.
 2624   2320   
#[derive(::std::fmt::Debug)]
 2625         -
pub enum MalformedShortError {
 2626         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2627         -
    ValidationException(crate::error::ValidationException),
        2321  +
pub enum StreamingTraitsRequireLengthError {
 2628   2322   
    #[allow(missing_docs)] // documentation missing in model
 2629   2323   
    InternalServerError(crate::error::InternalServerError),
 2630   2324   
}
 2631         -
impl ::std::fmt::Display for MalformedShortError {
        2325  +
impl ::std::fmt::Display for StreamingTraitsRequireLengthError {
 2632   2326   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2633   2327   
        match &self {
 2634         -
            MalformedShortError::ValidationException(_inner) => _inner.fmt(f),
 2635         -
            MalformedShortError::InternalServerError(_inner) => _inner.fmt(f),
        2328  +
            StreamingTraitsRequireLengthError::InternalServerError(_inner) => _inner.fmt(f),
 2636   2329   
        }
 2637   2330   
    }
 2638   2331   
}
 2639         -
impl MalformedShortError {
 2640         -
    /// Returns `true` if the error kind is `MalformedShortError::ValidationException`.
 2641         -
    pub fn is_validation_exception(&self) -> bool {
 2642         -
        matches!(&self, MalformedShortError::ValidationException(_))
 2643         -
    }
 2644         -
    /// Returns `true` if the error kind is `MalformedShortError::InternalServerError`.
        2332  +
impl StreamingTraitsRequireLengthError {
        2333  +
    /// Returns `true` if the error kind is `StreamingTraitsRequireLengthError::InternalServerError`.
 2645   2334   
    pub fn is_internal_server_error(&self) -> bool {
 2646         -
        matches!(&self, MalformedShortError::InternalServerError(_))
        2335  +
        matches!(
        2336  +
            &self,
        2337  +
            StreamingTraitsRequireLengthError::InternalServerError(_)
        2338  +
        )
 2647   2339   
    }
 2648   2340   
    /// Returns the error name string by matching the correct variant.
 2649   2341   
    pub fn name(&self) -> &'static str {
 2650   2342   
        match &self {
 2651         -
            MalformedShortError::ValidationException(_inner) => _inner.name(),
 2652         -
            MalformedShortError::InternalServerError(_inner) => _inner.name(),
        2343  +
            StreamingTraitsRequireLengthError::InternalServerError(_inner) => _inner.name(),
 2653   2344   
        }
 2654   2345   
    }
 2655   2346   
}
 2656         -
impl ::std::error::Error for MalformedShortError {
        2347  +
impl ::std::error::Error for StreamingTraitsRequireLengthError {
 2657   2348   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2658   2349   
        match &self {
 2659         -
            MalformedShortError::ValidationException(_inner) => Some(_inner),
 2660         -
            MalformedShortError::InternalServerError(_inner) => Some(_inner),
        2350  +
            StreamingTraitsRequireLengthError::InternalServerError(_inner) => Some(_inner),
 2661   2351   
        }
 2662   2352   
    }
 2663   2353   
}
 2664         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedShortError {
 2665         -
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedShortError {
 2666         -
        Self::ValidationException(variant)
 2667         -
    }
 2668         -
}
 2669         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedShortError {
 2670         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedShortError {
        2354  +
impl ::std::convert::From<crate::error::InternalServerError>
        2355  +
    for crate::error::StreamingTraitsRequireLengthError
        2356  +
{
        2357  +
    fn from(
        2358  +
        variant: crate::error::InternalServerError,
        2359  +
    ) -> crate::error::StreamingTraitsRequireLengthError {
 2671   2360   
        Self::InternalServerError(variant)
 2672   2361   
    }
 2673   2362   
}
 2674   2363   
 2675         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedShortError {
 2676         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedShortError {
        2364  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::StreamingTraitsRequireLengthError {
        2365  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::StreamingTraitsRequireLengthError {
 2677   2366   
        ::pyo3::Python::with_gil(|py| {
 2678   2367   
            let error = variant.value(py);
 2679         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2680         -
                return error.into();
 2681         -
            }
        2368  +
 2682   2369   
            crate::error::InternalServerError {
 2683   2370   
                message: error.to_string(),
 2684   2371   
            }
 2685   2372   
            .into()
 2686   2373   
        })
 2687   2374   
    }
 2688   2375   
}
 2689   2376   
 2690         -
/// Error type for the `MalformedByte` operation.
 2691         -
/// Each variant represents an error that can occur for the `MalformedByte` operation.
        2377  +
/// Error type for the `StreamingTraitsWithMediaType` operation.
        2378  +
/// Each variant represents an error that can occur for the `StreamingTraitsWithMediaType` operation.
 2692   2379   
#[derive(::std::fmt::Debug)]
 2693         -
pub enum MalformedByteError {
 2694         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2695         -
    ValidationException(crate::error::ValidationException),
        2380  +
pub enum StreamingTraitsWithMediaTypeError {
 2696   2381   
    #[allow(missing_docs)] // documentation missing in model
 2697   2382   
    InternalServerError(crate::error::InternalServerError),
 2698   2383   
}
 2699         -
impl ::std::fmt::Display for MalformedByteError {
        2384  +
impl ::std::fmt::Display for StreamingTraitsWithMediaTypeError {
 2700   2385   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2701   2386   
        match &self {
 2702         -
            MalformedByteError::ValidationException(_inner) => _inner.fmt(f),
 2703         -
            MalformedByteError::InternalServerError(_inner) => _inner.fmt(f),
        2387  +
            StreamingTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.fmt(f),
 2704   2388   
        }
 2705   2389   
    }
 2706   2390   
}
 2707         -
impl MalformedByteError {
 2708         -
    /// Returns `true` if the error kind is `MalformedByteError::ValidationException`.
 2709         -
    pub fn is_validation_exception(&self) -> bool {
 2710         -
        matches!(&self, MalformedByteError::ValidationException(_))
 2711         -
    }
 2712         -
    /// Returns `true` if the error kind is `MalformedByteError::InternalServerError`.
        2391  +
impl StreamingTraitsWithMediaTypeError {
        2392  +
    /// Returns `true` if the error kind is `StreamingTraitsWithMediaTypeError::InternalServerError`.
 2713   2393   
    pub fn is_internal_server_error(&self) -> bool {
 2714         -
        matches!(&self, MalformedByteError::InternalServerError(_))
        2394  +
        matches!(
        2395  +
            &self,
        2396  +
            StreamingTraitsWithMediaTypeError::InternalServerError(_)
        2397  +
        )
 2715   2398   
    }
 2716   2399   
    /// Returns the error name string by matching the correct variant.
 2717   2400   
    pub fn name(&self) -> &'static str {
 2718   2401   
        match &self {
 2719         -
            MalformedByteError::ValidationException(_inner) => _inner.name(),
 2720         -
            MalformedByteError::InternalServerError(_inner) => _inner.name(),
        2402  +
            StreamingTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.name(),
 2721   2403   
        }
 2722   2404   
    }
 2723   2405   
}
 2724         -
impl ::std::error::Error for MalformedByteError {
        2406  +
impl ::std::error::Error for StreamingTraitsWithMediaTypeError {
 2725   2407   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2726   2408   
        match &self {
 2727         -
            MalformedByteError::ValidationException(_inner) => Some(_inner),
 2728         -
            MalformedByteError::InternalServerError(_inner) => Some(_inner),
        2409  +
            StreamingTraitsWithMediaTypeError::InternalServerError(_inner) => Some(_inner),
 2729   2410   
        }
 2730   2411   
    }
 2731   2412   
}
 2732         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedByteError {
 2733         -
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedByteError {
 2734         -
        Self::ValidationException(variant)
 2735         -
    }
 2736         -
}
 2737         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedByteError {
 2738         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedByteError {
        2413  +
impl ::std::convert::From<crate::error::InternalServerError>
        2414  +
    for crate::error::StreamingTraitsWithMediaTypeError
        2415  +
{
        2416  +
    fn from(
        2417  +
        variant: crate::error::InternalServerError,
        2418  +
    ) -> crate::error::StreamingTraitsWithMediaTypeError {
 2739   2419   
        Self::InternalServerError(variant)
 2740   2420   
    }
 2741   2421   
}
 2742   2422   
 2743         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedByteError {
 2744         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedByteError {
        2423  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::StreamingTraitsWithMediaTypeError {
        2424  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::StreamingTraitsWithMediaTypeError {
 2745   2425   
        ::pyo3::Python::with_gil(|py| {
 2746   2426   
            let error = variant.value(py);
 2747         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2748         -
                return error.into();
 2749         -
            }
        2427  +
 2750   2428   
            crate::error::InternalServerError {
 2751   2429   
                message: error.to_string(),
 2752   2430   
            }
 2753   2431   
            .into()
 2754   2432   
        })
 2755   2433   
    }
 2756   2434   
}
 2757   2435   
 2758         -
/// Error type for the `MalformedBlob` operation.
 2759         -
/// Each variant represents an error that can occur for the `MalformedBlob` operation.
        2436  +
/// Error type for the `GreetingWithErrors` operation.
        2437  +
/// Each variant represents an error that can occur for the `GreetingWithErrors` operation.
 2760   2438   
#[derive(::std::fmt::Debug)]
 2761         -
pub enum MalformedBlobError {
        2439  +
pub enum GreetingWithErrorsError {
        2440  +
    /// This error is thrown when an invalid greeting value is provided.
        2441  +
    InvalidGreeting(crate::error::InvalidGreeting),
        2442  +
    /// This error is thrown when a request is invalid.
        2443  +
    ComplexError(crate::error::ComplexError),
        2444  +
    /// This error has test cases that test some of the dark corners of Amazon service framework history. It should only be implemented by clients.
        2445  +
    FooError(crate::error::FooError),
 2762   2446   
    #[allow(missing_docs)] // documentation missing in model
 2763   2447   
    InternalServerError(crate::error::InternalServerError),
 2764   2448   
}
 2765         -
impl ::std::fmt::Display for MalformedBlobError {
        2449  +
impl ::std::fmt::Display for GreetingWithErrorsError {
 2766   2450   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2767   2451   
        match &self {
 2768         -
            MalformedBlobError::InternalServerError(_inner) => _inner.fmt(f),
        2452  +
            GreetingWithErrorsError::InvalidGreeting(_inner) => _inner.fmt(f),
        2453  +
            GreetingWithErrorsError::ComplexError(_inner) => _inner.fmt(f),
        2454  +
            GreetingWithErrorsError::FooError(_inner) => _inner.fmt(f),
        2455  +
            GreetingWithErrorsError::InternalServerError(_inner) => _inner.fmt(f),
 2769   2456   
        }
 2770   2457   
    }
 2771   2458   
}
 2772         -
impl MalformedBlobError {
 2773         -
    /// Returns `true` if the error kind is `MalformedBlobError::InternalServerError`.
        2459  +
impl GreetingWithErrorsError {
        2460  +
    /// Returns `true` if the error kind is `GreetingWithErrorsError::InvalidGreeting`.
        2461  +
    pub fn is_invalid_greeting(&self) -> bool {
        2462  +
        matches!(&self, GreetingWithErrorsError::InvalidGreeting(_))
        2463  +
    }
        2464  +
    /// Returns `true` if the error kind is `GreetingWithErrorsError::ComplexError`.
        2465  +
    pub fn is_complex_error(&self) -> bool {
        2466  +
        matches!(&self, GreetingWithErrorsError::ComplexError(_))
        2467  +
    }
        2468  +
    /// Returns `true` if the error kind is `GreetingWithErrorsError::FooError`.
        2469  +
    pub fn is_foo_error(&self) -> bool {
        2470  +
        matches!(&self, GreetingWithErrorsError::FooError(_))
        2471  +
    }
        2472  +
    /// Returns `true` if the error kind is `GreetingWithErrorsError::InternalServerError`.
 2774   2473   
    pub fn is_internal_server_error(&self) -> bool {
 2775         -
        matches!(&self, MalformedBlobError::InternalServerError(_))
        2474  +
        matches!(&self, GreetingWithErrorsError::InternalServerError(_))
 2776   2475   
    }
 2777   2476   
    /// Returns the error name string by matching the correct variant.
 2778   2477   
    pub fn name(&self) -> &'static str {
 2779   2478   
        match &self {
 2780         -
            MalformedBlobError::InternalServerError(_inner) => _inner.name(),
        2479  +
            GreetingWithErrorsError::InvalidGreeting(_inner) => _inner.name(),
        2480  +
            GreetingWithErrorsError::ComplexError(_inner) => _inner.name(),
        2481  +
            GreetingWithErrorsError::FooError(_inner) => _inner.name(),
        2482  +
            GreetingWithErrorsError::InternalServerError(_inner) => _inner.name(),
 2781   2483   
        }
 2782   2484   
    }
 2783   2485   
}
 2784         -
impl ::std::error::Error for MalformedBlobError {
        2486  +
impl ::std::error::Error for GreetingWithErrorsError {
 2785   2487   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2786   2488   
        match &self {
 2787         -
            MalformedBlobError::InternalServerError(_inner) => Some(_inner),
        2489  +
            GreetingWithErrorsError::InvalidGreeting(_inner) => Some(_inner),
        2490  +
            GreetingWithErrorsError::ComplexError(_inner) => Some(_inner),
        2491  +
            GreetingWithErrorsError::FooError(_inner) => Some(_inner),
        2492  +
            GreetingWithErrorsError::InternalServerError(_inner) => Some(_inner),
 2788   2493   
        }
 2789   2494   
    }
 2790   2495   
}
 2791         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedBlobError {
 2792         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedBlobError {
        2496  +
impl ::std::convert::From<crate::error::InvalidGreeting> for crate::error::GreetingWithErrorsError {
        2497  +
    fn from(variant: crate::error::InvalidGreeting) -> crate::error::GreetingWithErrorsError {
        2498  +
        Self::InvalidGreeting(variant)
        2499  +
    }
        2500  +
}
        2501  +
impl ::std::convert::From<crate::error::ComplexError> for crate::error::GreetingWithErrorsError {
        2502  +
    fn from(variant: crate::error::ComplexError) -> crate::error::GreetingWithErrorsError {
        2503  +
        Self::ComplexError(variant)
        2504  +
    }
        2505  +
}
        2506  +
impl ::std::convert::From<crate::error::FooError> for crate::error::GreetingWithErrorsError {
        2507  +
    fn from(variant: crate::error::FooError) -> crate::error::GreetingWithErrorsError {
        2508  +
        Self::FooError(variant)
        2509  +
    }
        2510  +
}
        2511  +
impl ::std::convert::From<crate::error::InternalServerError>
        2512  +
    for crate::error::GreetingWithErrorsError
        2513  +
{
        2514  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::GreetingWithErrorsError {
 2793   2515   
        Self::InternalServerError(variant)
 2794   2516   
    }
 2795   2517   
}
 2796   2518   
 2797         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedBlobError {
 2798         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedBlobError {
        2519  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::GreetingWithErrorsError {
        2520  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::GreetingWithErrorsError {
 2799   2521   
        ::pyo3::Python::with_gil(|py| {
 2800   2522   
            let error = variant.value(py);
 2801         -
        2523  +
            if let Ok(error) = error.extract::<crate::error::InvalidGreeting>() {
        2524  +
                return error.into();
        2525  +
            }
        2526  +
            if let Ok(error) = error.extract::<crate::error::ComplexError>() {
        2527  +
                return error.into();
        2528  +
            }
        2529  +
            if let Ok(error) = error.extract::<crate::error::FooError>() {
        2530  +
                return error.into();
        2531  +
            }
 2802   2532   
            crate::error::InternalServerError {
 2803   2533   
                message: error.to_string(),
 2804   2534   
            }
 2805   2535   
            .into()
 2806   2536   
        })
 2807   2537   
    }
 2808   2538   
}
 2809   2539   
 2810         -
/// Error type for the `MalformedMap` operation.
 2811         -
/// Each variant represents an error that can occur for the `MalformedMap` operation.
        2540  +
/// Error type for the `SimpleScalarProperties` operation.
        2541  +
/// Each variant represents an error that can occur for the `SimpleScalarProperties` operation.
 2812   2542   
#[derive(::std::fmt::Debug)]
 2813         -
pub enum MalformedMapError {
        2543  +
pub enum SimpleScalarPropertiesError {
 2814   2544   
    #[allow(missing_docs)] // documentation missing in model
 2815   2545   
    InternalServerError(crate::error::InternalServerError),
 2816   2546   
}
 2817         -
impl ::std::fmt::Display for MalformedMapError {
        2547  +
impl ::std::fmt::Display for SimpleScalarPropertiesError {
 2818   2548   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2819   2549   
        match &self {
 2820         -
            MalformedMapError::InternalServerError(_inner) => _inner.fmt(f),
        2550  +
            SimpleScalarPropertiesError::InternalServerError(_inner) => _inner.fmt(f),
 2821   2551   
        }
 2822   2552   
    }
 2823   2553   
}
 2824         -
impl MalformedMapError {
 2825         -
    /// Returns `true` if the error kind is `MalformedMapError::InternalServerError`.
        2554  +
impl SimpleScalarPropertiesError {
        2555  +
    /// Returns `true` if the error kind is `SimpleScalarPropertiesError::InternalServerError`.
 2826   2556   
    pub fn is_internal_server_error(&self) -> bool {
 2827         -
        matches!(&self, MalformedMapError::InternalServerError(_))
        2557  +
        matches!(&self, SimpleScalarPropertiesError::InternalServerError(_))
 2828   2558   
    }
 2829   2559   
    /// Returns the error name string by matching the correct variant.
 2830   2560   
    pub fn name(&self) -> &'static str {
 2831   2561   
        match &self {
 2832         -
            MalformedMapError::InternalServerError(_inner) => _inner.name(),
        2562  +
            SimpleScalarPropertiesError::InternalServerError(_inner) => _inner.name(),
 2833   2563   
        }
 2834   2564   
    }
 2835   2565   
}
 2836         -
impl ::std::error::Error for MalformedMapError {
        2566  +
impl ::std::error::Error for SimpleScalarPropertiesError {
 2837   2567   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2838   2568   
        match &self {
 2839         -
            MalformedMapError::InternalServerError(_inner) => Some(_inner),
        2569  +
            SimpleScalarPropertiesError::InternalServerError(_inner) => Some(_inner),
 2840   2570   
        }
 2841   2571   
    }
 2842   2572   
}
 2843         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedMapError {
 2844         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedMapError {
        2573  +
impl ::std::convert::From<crate::error::InternalServerError>
        2574  +
    for crate::error::SimpleScalarPropertiesError
        2575  +
{
        2576  +
    fn from(
        2577  +
        variant: crate::error::InternalServerError,
        2578  +
    ) -> crate::error::SimpleScalarPropertiesError {
 2845   2579   
        Self::InternalServerError(variant)
 2846   2580   
    }
 2847   2581   
}
 2848   2582   
 2849         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedMapError {
 2850         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedMapError {
        2583  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::SimpleScalarPropertiesError {
        2584  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::SimpleScalarPropertiesError {
 2851   2585   
        ::pyo3::Python::with_gil(|py| {
 2852   2586   
            let error = variant.value(py);
 2853   2587   
 2854   2588   
            crate::error::InternalServerError {
 2855   2589   
                message: error.to_string(),
 2856   2590   
            }
 2857   2591   
            .into()
 2858   2592   
        })
 2859   2593   
    }
 2860   2594   
}
 2861   2595   
 2862         -
/// Error type for the `MalformedList` operation.
 2863         -
/// Each variant represents an error that can occur for the `MalformedList` operation.
        2596  +
/// Error type for the `JsonTimestamps` operation.
        2597  +
/// Each variant represents an error that can occur for the `JsonTimestamps` operation.
 2864   2598   
#[derive(::std::fmt::Debug)]
 2865         -
pub enum MalformedListError {
        2599  +
pub enum JsonTimestampsError {
 2866   2600   
    #[allow(missing_docs)] // documentation missing in model
 2867   2601   
    InternalServerError(crate::error::InternalServerError),
 2868   2602   
}
 2869         -
impl ::std::fmt::Display for MalformedListError {
        2603  +
impl ::std::fmt::Display for JsonTimestampsError {
 2870   2604   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2871   2605   
        match &self {
 2872         -
            MalformedListError::InternalServerError(_inner) => _inner.fmt(f),
        2606  +
            JsonTimestampsError::InternalServerError(_inner) => _inner.fmt(f),
 2873   2607   
        }
 2874   2608   
    }
 2875   2609   
}
 2876         -
impl MalformedListError {
 2877         -
    /// Returns `true` if the error kind is `MalformedListError::InternalServerError`.
        2610  +
impl JsonTimestampsError {
        2611  +
    /// Returns `true` if the error kind is `JsonTimestampsError::InternalServerError`.
 2878   2612   
    pub fn is_internal_server_error(&self) -> bool {
 2879         -
        matches!(&self, MalformedListError::InternalServerError(_))
        2613  +
        matches!(&self, JsonTimestampsError::InternalServerError(_))
 2880   2614   
    }
 2881   2615   
    /// Returns the error name string by matching the correct variant.
 2882   2616   
    pub fn name(&self) -> &'static str {
 2883   2617   
        match &self {
 2884         -
            MalformedListError::InternalServerError(_inner) => _inner.name(),
        2618  +
            JsonTimestampsError::InternalServerError(_inner) => _inner.name(),
 2885   2619   
        }
 2886   2620   
    }
 2887   2621   
}
 2888         -
impl ::std::error::Error for MalformedListError {
        2622  +
impl ::std::error::Error for JsonTimestampsError {
 2889   2623   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2890   2624   
        match &self {
 2891         -
            MalformedListError::InternalServerError(_inner) => Some(_inner),
        2625  +
            JsonTimestampsError::InternalServerError(_inner) => Some(_inner),
 2892   2626   
        }
 2893   2627   
    }
 2894   2628   
}
 2895         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedListError {
 2896         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedListError {
        2629  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonTimestampsError {
        2630  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonTimestampsError {
 2897   2631   
        Self::InternalServerError(variant)
 2898   2632   
    }
 2899   2633   
}
 2900   2634   
 2901         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedListError {
 2902         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedListError {
        2635  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonTimestampsError {
        2636  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonTimestampsError {
 2903   2637   
        ::pyo3::Python::with_gil(|py| {
 2904   2638   
            let error = variant.value(py);
 2905   2639   
 2906   2640   
            crate::error::InternalServerError {
 2907   2641   
                message: error.to_string(),
 2908   2642   
            }
 2909   2643   
            .into()
 2910   2644   
        })
 2911   2645   
    }
 2912   2646   
}
 2913   2647   
 2914         -
/// Error type for the `MalformedBoolean` operation.
 2915         -
/// Each variant represents an error that can occur for the `MalformedBoolean` operation.
        2648  +
/// Error type for the `JsonEnums` operation.
        2649  +
/// Each variant represents an error that can occur for the `JsonEnums` operation.
 2916   2650   
#[derive(::std::fmt::Debug)]
 2917         -
pub enum MalformedBooleanError {
        2651  +
pub enum JsonEnumsError {
 2918   2652   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 2919   2653   
    ValidationException(crate::error::ValidationException),
 2920   2654   
    #[allow(missing_docs)] // documentation missing in model
 2921   2655   
    InternalServerError(crate::error::InternalServerError),
 2922   2656   
}
 2923         -
impl ::std::fmt::Display for MalformedBooleanError {
        2657  +
impl ::std::fmt::Display for JsonEnumsError {
 2924   2658   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2925   2659   
        match &self {
 2926         -
            MalformedBooleanError::ValidationException(_inner) => _inner.fmt(f),
 2927         -
            MalformedBooleanError::InternalServerError(_inner) => _inner.fmt(f),
        2660  +
            JsonEnumsError::ValidationException(_inner) => _inner.fmt(f),
        2661  +
            JsonEnumsError::InternalServerError(_inner) => _inner.fmt(f),
 2928   2662   
        }
 2929   2663   
    }
 2930   2664   
}
 2931         -
impl MalformedBooleanError {
 2932         -
    /// Returns `true` if the error kind is `MalformedBooleanError::ValidationException`.
        2665  +
impl JsonEnumsError {
        2666  +
    /// Returns `true` if the error kind is `JsonEnumsError::ValidationException`.
 2933   2667   
    pub fn is_validation_exception(&self) -> bool {
 2934         -
        matches!(&self, MalformedBooleanError::ValidationException(_))
        2668  +
        matches!(&self, JsonEnumsError::ValidationException(_))
 2935   2669   
    }
 2936         -
    /// Returns `true` if the error kind is `MalformedBooleanError::InternalServerError`.
        2670  +
    /// Returns `true` if the error kind is `JsonEnumsError::InternalServerError`.
 2937   2671   
    pub fn is_internal_server_error(&self) -> bool {
 2938         -
        matches!(&self, MalformedBooleanError::InternalServerError(_))
        2672  +
        matches!(&self, JsonEnumsError::InternalServerError(_))
 2939   2673   
    }
 2940   2674   
    /// Returns the error name string by matching the correct variant.
 2941   2675   
    pub fn name(&self) -> &'static str {
 2942   2676   
        match &self {
 2943         -
            MalformedBooleanError::ValidationException(_inner) => _inner.name(),
 2944         -
            MalformedBooleanError::InternalServerError(_inner) => _inner.name(),
        2677  +
            JsonEnumsError::ValidationException(_inner) => _inner.name(),
        2678  +
            JsonEnumsError::InternalServerError(_inner) => _inner.name(),
 2945   2679   
        }
 2946   2680   
    }
 2947   2681   
}
 2948         -
impl ::std::error::Error for MalformedBooleanError {
        2682  +
impl ::std::error::Error for JsonEnumsError {
 2949   2683   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 2950   2684   
        match &self {
 2951         -
            MalformedBooleanError::ValidationException(_inner) => Some(_inner),
 2952         -
            MalformedBooleanError::InternalServerError(_inner) => Some(_inner),
        2685  +
            JsonEnumsError::ValidationException(_inner) => Some(_inner),
        2686  +
            JsonEnumsError::InternalServerError(_inner) => Some(_inner),
 2953   2687   
        }
 2954   2688   
    }
 2955   2689   
}
 2956         -
impl ::std::convert::From<crate::error::ValidationException>
 2957         -
    for crate::error::MalformedBooleanError
 2958         -
{
 2959         -
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedBooleanError {
        2690  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonEnumsError {
        2691  +
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonEnumsError {
 2960   2692   
        Self::ValidationException(variant)
 2961   2693   
    }
 2962   2694   
}
 2963         -
impl ::std::convert::From<crate::error::InternalServerError>
 2964         -
    for crate::error::MalformedBooleanError
 2965         -
{
 2966         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedBooleanError {
        2695  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonEnumsError {
        2696  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonEnumsError {
 2967   2697   
        Self::InternalServerError(variant)
 2968   2698   
    }
 2969   2699   
}
 2970   2700   
 2971         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedBooleanError {
 2972         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedBooleanError {
        2701  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonEnumsError {
        2702  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonEnumsError {
 2973   2703   
        ::pyo3::Python::with_gil(|py| {
 2974   2704   
            let error = variant.value(py);
 2975   2705   
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 2976   2706   
                return error.into();
 2977   2707   
            }
 2978   2708   
            crate::error::InternalServerError {
 2979   2709   
                message: error.to_string(),
 2980   2710   
            }
 2981   2711   
            .into()
 2982   2712   
        })
 2983   2713   
    }
 2984   2714   
}
 2985   2715   
 2986         -
/// Error type for the `MalformedUnion` operation.
 2987         -
/// Each variant represents an error that can occur for the `MalformedUnion` operation.
        2716  +
/// Error type for the `JsonIntEnums` operation.
        2717  +
/// Each variant represents an error that can occur for the `JsonIntEnums` operation.
 2988   2718   
#[derive(::std::fmt::Debug)]
 2989         -
pub enum MalformedUnionError {
        2719  +
pub enum JsonIntEnumsError {
        2720  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        2721  +
    ValidationException(crate::error::ValidationException),
 2990   2722   
    #[allow(missing_docs)] // documentation missing in model
 2991   2723   
    InternalServerError(crate::error::InternalServerError),
 2992   2724   
}
 2993         -
impl ::std::fmt::Display for MalformedUnionError {
        2725  +
impl ::std::fmt::Display for JsonIntEnumsError {
 2994   2726   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 2995   2727   
        match &self {
 2996         -
            MalformedUnionError::InternalServerError(_inner) => _inner.fmt(f),
        2728  +
            JsonIntEnumsError::ValidationException(_inner) => _inner.fmt(f),
        2729  +
            JsonIntEnumsError::InternalServerError(_inner) => _inner.fmt(f),
 2997   2730   
        }
 2998   2731   
    }
 2999   2732   
}
 3000         -
impl MalformedUnionError {
 3001         -
    /// Returns `true` if the error kind is `MalformedUnionError::InternalServerError`.
        2733  +
impl JsonIntEnumsError {
        2734  +
    /// Returns `true` if the error kind is `JsonIntEnumsError::ValidationException`.
        2735  +
    pub fn is_validation_exception(&self) -> bool {
        2736  +
        matches!(&self, JsonIntEnumsError::ValidationException(_))
        2737  +
    }
        2738  +
    /// Returns `true` if the error kind is `JsonIntEnumsError::InternalServerError`.
 3002   2739   
    pub fn is_internal_server_error(&self) -> bool {
 3003         -
        matches!(&self, MalformedUnionError::InternalServerError(_))
        2740  +
        matches!(&self, JsonIntEnumsError::InternalServerError(_))
 3004   2741   
    }
 3005   2742   
    /// Returns the error name string by matching the correct variant.
 3006   2743   
    pub fn name(&self) -> &'static str {
 3007   2744   
        match &self {
 3008         -
            MalformedUnionError::InternalServerError(_inner) => _inner.name(),
        2745  +
            JsonIntEnumsError::ValidationException(_inner) => _inner.name(),
        2746  +
            JsonIntEnumsError::InternalServerError(_inner) => _inner.name(),
 3009   2747   
        }
 3010   2748   
    }
 3011   2749   
}
 3012         -
impl ::std::error::Error for MalformedUnionError {
        2750  +
impl ::std::error::Error for JsonIntEnumsError {
 3013   2751   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3014   2752   
        match &self {
 3015         -
            MalformedUnionError::InternalServerError(_inner) => Some(_inner),
        2753  +
            JsonIntEnumsError::ValidationException(_inner) => Some(_inner),
        2754  +
            JsonIntEnumsError::InternalServerError(_inner) => Some(_inner),
 3016   2755   
        }
 3017   2756   
    }
 3018   2757   
}
 3019         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedUnionError {
 3020         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedUnionError {
        2758  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonIntEnumsError {
        2759  +
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonIntEnumsError {
        2760  +
        Self::ValidationException(variant)
        2761  +
    }
        2762  +
}
        2763  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonIntEnumsError {
        2764  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonIntEnumsError {
 3021   2765   
        Self::InternalServerError(variant)
 3022   2766   
    }
 3023   2767   
}
 3024   2768   
 3025         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedUnionError {
 3026         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedUnionError {
        2769  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonIntEnumsError {
        2770  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonIntEnumsError {
 3027   2771   
        ::pyo3::Python::with_gil(|py| {
 3028   2772   
            let error = variant.value(py);
 3029         -
        2773  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        2774  +
                return error.into();
        2775  +
            }
 3030   2776   
            crate::error::InternalServerError {
 3031   2777   
                message: error.to_string(),
 3032   2778   
            }
 3033   2779   
            .into()
 3034   2780   
        })
 3035   2781   
    }
 3036   2782   
}
 3037   2783   
 3038         -
/// Error type for the `MalformedInteger` operation.
 3039         -
/// Each variant represents an error that can occur for the `MalformedInteger` operation.
        2784  +
/// Error type for the `RecursiveShapes` operation.
        2785  +
/// Each variant represents an error that can occur for the `RecursiveShapes` operation.
 3040   2786   
#[derive(::std::fmt::Debug)]
 3041         -
pub enum MalformedIntegerError {
 3042         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 3043         -
    ValidationException(crate::error::ValidationException),
        2787  +
pub enum RecursiveShapesError {
 3044   2788   
    #[allow(missing_docs)] // documentation missing in model
 3045   2789   
    InternalServerError(crate::error::InternalServerError),
 3046   2790   
}
 3047         -
impl ::std::fmt::Display for MalformedIntegerError {
        2791  +
impl ::std::fmt::Display for RecursiveShapesError {
 3048   2792   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3049   2793   
        match &self {
 3050         -
            MalformedIntegerError::ValidationException(_inner) => _inner.fmt(f),
 3051         -
            MalformedIntegerError::InternalServerError(_inner) => _inner.fmt(f),
        2794  +
            RecursiveShapesError::InternalServerError(_inner) => _inner.fmt(f),
 3052   2795   
        }
 3053   2796   
    }
 3054   2797   
}
 3055         -
impl MalformedIntegerError {
 3056         -
    /// Returns `true` if the error kind is `MalformedIntegerError::ValidationException`.
 3057         -
    pub fn is_validation_exception(&self) -> bool {
 3058         -
        matches!(&self, MalformedIntegerError::ValidationException(_))
 3059         -
    }
 3060         -
    /// Returns `true` if the error kind is `MalformedIntegerError::InternalServerError`.
        2798  +
impl RecursiveShapesError {
        2799  +
    /// Returns `true` if the error kind is `RecursiveShapesError::InternalServerError`.
 3061   2800   
    pub fn is_internal_server_error(&self) -> bool {
 3062         -
        matches!(&self, MalformedIntegerError::InternalServerError(_))
        2801  +
        matches!(&self, RecursiveShapesError::InternalServerError(_))
 3063   2802   
    }
 3064   2803   
    /// Returns the error name string by matching the correct variant.
 3065   2804   
    pub fn name(&self) -> &'static str {
 3066   2805   
        match &self {
 3067         -
            MalformedIntegerError::ValidationException(_inner) => _inner.name(),
 3068         -
            MalformedIntegerError::InternalServerError(_inner) => _inner.name(),
        2806  +
            RecursiveShapesError::InternalServerError(_inner) => _inner.name(),
 3069   2807   
        }
 3070   2808   
    }
 3071   2809   
}
 3072         -
impl ::std::error::Error for MalformedIntegerError {
        2810  +
impl ::std::error::Error for RecursiveShapesError {
 3073   2811   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3074   2812   
        match &self {
 3075         -
            MalformedIntegerError::ValidationException(_inner) => Some(_inner),
 3076         -
            MalformedIntegerError::InternalServerError(_inner) => Some(_inner),
        2813  +
            RecursiveShapesError::InternalServerError(_inner) => Some(_inner),
 3077   2814   
        }
 3078   2815   
    }
 3079   2816   
}
 3080         -
impl ::std::convert::From<crate::error::ValidationException>
 3081         -
    for crate::error::MalformedIntegerError
 3082         -
{
 3083         -
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedIntegerError {
 3084         -
        Self::ValidationException(variant)
 3085         -
    }
 3086         -
}
 3087   2817   
impl ::std::convert::From<crate::error::InternalServerError>
 3088         -
    for crate::error::MalformedIntegerError
        2818  +
    for crate::error::RecursiveShapesError
 3089   2819   
{
 3090         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedIntegerError {
        2820  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::RecursiveShapesError {
 3091   2821   
        Self::InternalServerError(variant)
 3092   2822   
    }
 3093   2823   
}
 3094   2824   
 3095         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedIntegerError {
 3096         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedIntegerError {
        2825  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::RecursiveShapesError {
        2826  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::RecursiveShapesError {
 3097   2827   
        ::pyo3::Python::with_gil(|py| {
 3098   2828   
            let error = variant.value(py);
 3099         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 3100         -
                return error.into();
 3101         -
            }
        2829  +
 3102   2830   
            crate::error::InternalServerError {
 3103   2831   
                message: error.to_string(),
 3104   2832   
            }
 3105   2833   
            .into()
 3106   2834   
        })
 3107   2835   
    }
 3108   2836   
}
 3109   2837   
 3110         -
/// Error type for the `MalformedRequestBody` operation.
 3111         -
/// Each variant represents an error that can occur for the `MalformedRequestBody` operation.
        2838  +
/// Error type for the `JsonLists` operation.
        2839  +
/// Each variant represents an error that can occur for the `JsonLists` operation.
 3112   2840   
#[derive(::std::fmt::Debug)]
 3113         -
pub enum MalformedRequestBodyError {
        2841  +
pub enum JsonListsError {
        2842  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        2843  +
    ValidationException(crate::error::ValidationException),
 3114   2844   
    #[allow(missing_docs)] // documentation missing in model
 3115   2845   
    InternalServerError(crate::error::InternalServerError),
 3116   2846   
}
 3117         -
impl ::std::fmt::Display for MalformedRequestBodyError {
        2847  +
impl ::std::fmt::Display for JsonListsError {
 3118   2848   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3119   2849   
        match &self {
 3120         -
            MalformedRequestBodyError::InternalServerError(_inner) => _inner.fmt(f),
        2850  +
            JsonListsError::ValidationException(_inner) => _inner.fmt(f),
        2851  +
            JsonListsError::InternalServerError(_inner) => _inner.fmt(f),
 3121   2852   
        }
 3122   2853   
    }
 3123   2854   
}
 3124         -
impl MalformedRequestBodyError {
 3125         -
    /// Returns `true` if the error kind is `MalformedRequestBodyError::InternalServerError`.
        2855  +
impl JsonListsError {
        2856  +
    /// Returns `true` if the error kind is `JsonListsError::ValidationException`.
        2857  +
    pub fn is_validation_exception(&self) -> bool {
        2858  +
        matches!(&self, JsonListsError::ValidationException(_))
        2859  +
    }
        2860  +
    /// Returns `true` if the error kind is `JsonListsError::InternalServerError`.
 3126   2861   
    pub fn is_internal_server_error(&self) -> bool {
 3127         -
        matches!(&self, MalformedRequestBodyError::InternalServerError(_))
        2862  +
        matches!(&self, JsonListsError::InternalServerError(_))
 3128   2863   
    }
 3129   2864   
    /// Returns the error name string by matching the correct variant.
 3130   2865   
    pub fn name(&self) -> &'static str {
 3131   2866   
        match &self {
 3132         -
            MalformedRequestBodyError::InternalServerError(_inner) => _inner.name(),
        2867  +
            JsonListsError::ValidationException(_inner) => _inner.name(),
        2868  +
            JsonListsError::InternalServerError(_inner) => _inner.name(),
 3133   2869   
        }
 3134   2870   
    }
 3135   2871   
}
 3136         -
impl ::std::error::Error for MalformedRequestBodyError {
        2872  +
impl ::std::error::Error for JsonListsError {
 3137   2873   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3138   2874   
        match &self {
 3139         -
            MalformedRequestBodyError::InternalServerError(_inner) => Some(_inner),
        2875  +
            JsonListsError::ValidationException(_inner) => Some(_inner),
        2876  +
            JsonListsError::InternalServerError(_inner) => Some(_inner),
 3140   2877   
        }
 3141   2878   
    }
 3142   2879   
}
 3143         -
impl ::std::convert::From<crate::error::InternalServerError>
 3144         -
    for crate::error::MalformedRequestBodyError
 3145         -
{
 3146         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedRequestBodyError {
        2880  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonListsError {
        2881  +
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonListsError {
        2882  +
        Self::ValidationException(variant)
        2883  +
    }
        2884  +
}
        2885  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonListsError {
        2886  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonListsError {
 3147   2887   
        Self::InternalServerError(variant)
 3148   2888   
    }
 3149   2889   
}
 3150   2890   
 3151         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedRequestBodyError {
 3152         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedRequestBodyError {
        2891  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonListsError {
        2892  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonListsError {
 3153   2893   
        ::pyo3::Python::with_gil(|py| {
 3154   2894   
            let error = variant.value(py);
 3155         -
        2895  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        2896  +
                return error.into();
        2897  +
            }
 3156   2898   
            crate::error::InternalServerError {
 3157   2899   
                message: error.to_string(),
 3158   2900   
            }
 3159   2901   
            .into()
 3160   2902   
        })
 3161   2903   
    }
 3162   2904   
}
 3163   2905   
 3164         -
/// Error type for the `HttpChecksumRequired` operation.
 3165         -
/// Each variant represents an error that can occur for the `HttpChecksumRequired` operation.
        2906  +
/// Error type for the `SparseJsonLists` operation.
        2907  +
/// Each variant represents an error that can occur for the `SparseJsonLists` operation.
 3166   2908   
#[derive(::std::fmt::Debug)]
 3167         -
pub enum HttpChecksumRequiredError {
        2909  +
pub enum SparseJsonListsError {
 3168   2910   
    #[allow(missing_docs)] // documentation missing in model
 3169   2911   
    InternalServerError(crate::error::InternalServerError),
 3170   2912   
}
 3171         -
impl ::std::fmt::Display for HttpChecksumRequiredError {
        2913  +
impl ::std::fmt::Display for SparseJsonListsError {
 3172   2914   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3173   2915   
        match &self {
 3174         -
            HttpChecksumRequiredError::InternalServerError(_inner) => _inner.fmt(f),
        2916  +
            SparseJsonListsError::InternalServerError(_inner) => _inner.fmt(f),
 3175   2917   
        }
 3176   2918   
    }
 3177   2919   
}
 3178         -
impl HttpChecksumRequiredError {
 3179         -
    /// Returns `true` if the error kind is `HttpChecksumRequiredError::InternalServerError`.
        2920  +
impl SparseJsonListsError {
        2921  +
    /// Returns `true` if the error kind is `SparseJsonListsError::InternalServerError`.
 3180   2922   
    pub fn is_internal_server_error(&self) -> bool {
 3181         -
        matches!(&self, HttpChecksumRequiredError::InternalServerError(_))
        2923  +
        matches!(&self, SparseJsonListsError::InternalServerError(_))
 3182   2924   
    }
 3183   2925   
    /// Returns the error name string by matching the correct variant.
 3184   2926   
    pub fn name(&self) -> &'static str {
 3185   2927   
        match &self {
 3186         -
            HttpChecksumRequiredError::InternalServerError(_inner) => _inner.name(),
        2928  +
            SparseJsonListsError::InternalServerError(_inner) => _inner.name(),
 3187   2929   
        }
 3188   2930   
    }
 3189   2931   
}
 3190         -
impl ::std::error::Error for HttpChecksumRequiredError {
        2932  +
impl ::std::error::Error for SparseJsonListsError {
 3191   2933   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3192   2934   
        match &self {
 3193         -
            HttpChecksumRequiredError::InternalServerError(_inner) => Some(_inner),
        2935  +
            SparseJsonListsError::InternalServerError(_inner) => Some(_inner),
 3194   2936   
        }
 3195   2937   
    }
 3196   2938   
}
 3197   2939   
impl ::std::convert::From<crate::error::InternalServerError>
 3198         -
    for crate::error::HttpChecksumRequiredError
        2940  +
    for crate::error::SparseJsonListsError
 3199   2941   
{
 3200         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpChecksumRequiredError {
        2942  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::SparseJsonListsError {
 3201   2943   
        Self::InternalServerError(variant)
 3202   2944   
    }
 3203   2945   
}
 3204   2946   
 3205         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpChecksumRequiredError {
 3206         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpChecksumRequiredError {
        2947  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::SparseJsonListsError {
        2948  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::SparseJsonListsError {
 3207   2949   
        ::pyo3::Python::with_gil(|py| {
 3208   2950   
            let error = variant.value(py);
 3209   2951   
 3210   2952   
            crate::error::InternalServerError {
 3211   2953   
                message: error.to_string(),
 3212   2954   
            }
 3213   2955   
            .into()
 3214   2956   
        })
 3215   2957   
    }
 3216   2958   
}
 3217   2959   
 3218         -
/// Error type for the `HostWithPathOperation` operation.
 3219         -
/// Each variant represents an error that can occur for the `HostWithPathOperation` operation.
        2960  +
/// Error type for the `JsonMaps` operation.
        2961  +
/// Each variant represents an error that can occur for the `JsonMaps` operation.
 3220   2962   
#[derive(::std::fmt::Debug)]
 3221         -
pub enum HostWithPathOperationError {
        2963  +
pub enum JsonMapsError {
        2964  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        2965  +
    ValidationException(crate::error::ValidationException),
 3222   2966   
    #[allow(missing_docs)] // documentation missing in model
 3223   2967   
    InternalServerError(crate::error::InternalServerError),
 3224   2968   
}
 3225         -
impl ::std::fmt::Display for HostWithPathOperationError {
        2969  +
impl ::std::fmt::Display for JsonMapsError {
 3226   2970   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3227   2971   
        match &self {
 3228         -
            HostWithPathOperationError::InternalServerError(_inner) => _inner.fmt(f),
        2972  +
            JsonMapsError::ValidationException(_inner) => _inner.fmt(f),
        2973  +
            JsonMapsError::InternalServerError(_inner) => _inner.fmt(f),
 3229   2974   
        }
 3230   2975   
    }
 3231   2976   
}
 3232         -
impl HostWithPathOperationError {
 3233         -
    /// Returns `true` if the error kind is `HostWithPathOperationError::InternalServerError`.
        2977  +
impl JsonMapsError {
        2978  +
    /// Returns `true` if the error kind is `JsonMapsError::ValidationException`.
        2979  +
    pub fn is_validation_exception(&self) -> bool {
        2980  +
        matches!(&self, JsonMapsError::ValidationException(_))
        2981  +
    }
        2982  +
    /// Returns `true` if the error kind is `JsonMapsError::InternalServerError`.
 3234   2983   
    pub fn is_internal_server_error(&self) -> bool {
 3235         -
        matches!(&self, HostWithPathOperationError::InternalServerError(_))
        2984  +
        matches!(&self, JsonMapsError::InternalServerError(_))
 3236   2985   
    }
 3237   2986   
    /// Returns the error name string by matching the correct variant.
 3238   2987   
    pub fn name(&self) -> &'static str {
 3239   2988   
        match &self {
 3240         -
            HostWithPathOperationError::InternalServerError(_inner) => _inner.name(),
        2989  +
            JsonMapsError::ValidationException(_inner) => _inner.name(),
        2990  +
            JsonMapsError::InternalServerError(_inner) => _inner.name(),
 3241   2991   
        }
 3242   2992   
    }
 3243   2993   
}
 3244         -
impl ::std::error::Error for HostWithPathOperationError {
        2994  +
impl ::std::error::Error for JsonMapsError {
 3245   2995   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3246   2996   
        match &self {
 3247         -
            HostWithPathOperationError::InternalServerError(_inner) => Some(_inner),
        2997  +
            JsonMapsError::ValidationException(_inner) => Some(_inner),
        2998  +
            JsonMapsError::InternalServerError(_inner) => Some(_inner),
 3248   2999   
        }
 3249   3000   
    }
 3250   3001   
}
 3251         -
impl ::std::convert::From<crate::error::InternalServerError>
 3252         -
    for crate::error::HostWithPathOperationError
 3253         -
{
 3254         -
    fn from(
 3255         -
        variant: crate::error::InternalServerError,
 3256         -
    ) -> crate::error::HostWithPathOperationError {
        3002  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonMapsError {
        3003  +
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonMapsError {
        3004  +
        Self::ValidationException(variant)
        3005  +
    }
        3006  +
}
        3007  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonMapsError {
        3008  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonMapsError {
 3257   3009   
        Self::InternalServerError(variant)
 3258   3010   
    }
 3259   3011   
}
 3260   3012   
 3261         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HostWithPathOperationError {
 3262         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HostWithPathOperationError {
        3013  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonMapsError {
        3014  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonMapsError {
 3263   3015   
        ::pyo3::Python::with_gil(|py| {
 3264   3016   
            let error = variant.value(py);
 3265         -
        3017  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        3018  +
                return error.into();
        3019  +
            }
 3266   3020   
            crate::error::InternalServerError {
 3267   3021   
                message: error.to_string(),
 3268   3022   
            }
 3269   3023   
            .into()
 3270   3024   
        })
 3271   3025   
    }
 3272   3026   
}
 3273   3027   
 3274         -
/// Error type for the `EndpointWithHostLabelOperation` operation.
 3275         -
/// Each variant represents an error that can occur for the `EndpointWithHostLabelOperation` operation.
        3028  +
/// Error type for the `SparseJsonMaps` operation.
        3029  +
/// Each variant represents an error that can occur for the `SparseJsonMaps` operation.
 3276   3030   
#[derive(::std::fmt::Debug)]
 3277         -
pub enum EndpointWithHostLabelOperationError {
        3031  +
pub enum SparseJsonMapsError {
 3278   3032   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 3279   3033   
    ValidationException(crate::error::ValidationException),
 3280   3034   
    #[allow(missing_docs)] // documentation missing in model
 3281   3035   
    InternalServerError(crate::error::InternalServerError),
 3282   3036   
}
 3283         -
impl ::std::fmt::Display for EndpointWithHostLabelOperationError {
        3037  +
impl ::std::fmt::Display for SparseJsonMapsError {
 3284   3038   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3285   3039   
        match &self {
 3286         -
            EndpointWithHostLabelOperationError::ValidationException(_inner) => _inner.fmt(f),
 3287         -
            EndpointWithHostLabelOperationError::InternalServerError(_inner) => _inner.fmt(f),
        3040  +
            SparseJsonMapsError::ValidationException(_inner) => _inner.fmt(f),
        3041  +
            SparseJsonMapsError::InternalServerError(_inner) => _inner.fmt(f),
 3288   3042   
        }
 3289   3043   
    }
 3290   3044   
}
 3291         -
impl EndpointWithHostLabelOperationError {
 3292         -
    /// Returns `true` if the error kind is `EndpointWithHostLabelOperationError::ValidationException`.
        3045  +
impl SparseJsonMapsError {
        3046  +
    /// Returns `true` if the error kind is `SparseJsonMapsError::ValidationException`.
 3293   3047   
    pub fn is_validation_exception(&self) -> bool {
 3294         -
        matches!(
 3295         -
            &self,
 3296         -
            EndpointWithHostLabelOperationError::ValidationException(_)
 3297         -
        )
        3048  +
        matches!(&self, SparseJsonMapsError::ValidationException(_))
 3298   3049   
    }
 3299         -
    /// Returns `true` if the error kind is `EndpointWithHostLabelOperationError::InternalServerError`.
        3050  +
    /// Returns `true` if the error kind is `SparseJsonMapsError::InternalServerError`.
 3300   3051   
    pub fn is_internal_server_error(&self) -> bool {
 3301         -
        matches!(
 3302         -
            &self,
 3303         -
            EndpointWithHostLabelOperationError::InternalServerError(_)
 3304         -
        )
        3052  +
        matches!(&self, SparseJsonMapsError::InternalServerError(_))
 3305   3053   
    }
 3306   3054   
    /// Returns the error name string by matching the correct variant.
 3307   3055   
    pub fn name(&self) -> &'static str {
 3308   3056   
        match &self {
 3309         -
            EndpointWithHostLabelOperationError::ValidationException(_inner) => _inner.name(),
 3310         -
            EndpointWithHostLabelOperationError::InternalServerError(_inner) => _inner.name(),
        3057  +
            SparseJsonMapsError::ValidationException(_inner) => _inner.name(),
        3058  +
            SparseJsonMapsError::InternalServerError(_inner) => _inner.name(),
 3311   3059   
        }
 3312   3060   
    }
 3313   3061   
}
 3314         -
impl ::std::error::Error for EndpointWithHostLabelOperationError {
        3062  +
impl ::std::error::Error for SparseJsonMapsError {
 3315   3063   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3316   3064   
        match &self {
 3317         -
            EndpointWithHostLabelOperationError::ValidationException(_inner) => Some(_inner),
 3318         -
            EndpointWithHostLabelOperationError::InternalServerError(_inner) => Some(_inner),
        3065  +
            SparseJsonMapsError::ValidationException(_inner) => Some(_inner),
        3066  +
            SparseJsonMapsError::InternalServerError(_inner) => Some(_inner),
 3319   3067   
        }
 3320   3068   
    }
 3321   3069   
}
 3322         -
impl ::std::convert::From<crate::error::ValidationException>
 3323         -
    for crate::error::EndpointWithHostLabelOperationError
 3324         -
{
 3325         -
    fn from(
 3326         -
        variant: crate::error::ValidationException,
 3327         -
    ) -> crate::error::EndpointWithHostLabelOperationError {
        3070  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::SparseJsonMapsError {
        3071  +
    fn from(variant: crate::error::ValidationException) -> crate::error::SparseJsonMapsError {
 3328   3072   
        Self::ValidationException(variant)
 3329   3073   
    }
 3330   3074   
}
 3331         -
impl ::std::convert::From<crate::error::InternalServerError>
 3332         -
    for crate::error::EndpointWithHostLabelOperationError
 3333         -
{
 3334         -
    fn from(
 3335         -
        variant: crate::error::InternalServerError,
 3336         -
    ) -> crate::error::EndpointWithHostLabelOperationError {
        3075  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::SparseJsonMapsError {
        3076  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::SparseJsonMapsError {
 3337   3077   
        Self::InternalServerError(variant)
 3338   3078   
    }
 3339   3079   
}
 3340   3080   
 3341         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::EndpointWithHostLabelOperationError {
 3342         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::EndpointWithHostLabelOperationError {
 3343         -
        ::pyo3::Python::with_gil(|py| {
        3081  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::SparseJsonMapsError {
        3082  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::SparseJsonMapsError {
        3083  +
        ::pyo3::Python::with_gil(|py| {
 3344   3084   
            let error = variant.value(py);
 3345   3085   
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 3346   3086   
                return error.into();
 3347   3087   
            }
 3348   3088   
            crate::error::InternalServerError {
 3349   3089   
                message: error.to_string(),
 3350   3090   
            }
 3351   3091   
            .into()
 3352   3092   
        })
 3353   3093   
    }
 3354   3094   
}
 3355   3095   
 3356         -
/// Error type for the `EndpointOperation` operation.
 3357         -
/// Each variant represents an error that can occur for the `EndpointOperation` operation.
        3096  +
/// Error type for the `JsonBlobs` operation.
        3097  +
/// Each variant represents an error that can occur for the `JsonBlobs` operation.
 3358   3098   
#[derive(::std::fmt::Debug)]
 3359         -
pub enum EndpointOperationError {
        3099  +
pub enum JsonBlobsError {
 3360   3100   
    #[allow(missing_docs)] // documentation missing in model
 3361   3101   
    InternalServerError(crate::error::InternalServerError),
 3362   3102   
}
 3363         -
impl ::std::fmt::Display for EndpointOperationError {
        3103  +
impl ::std::fmt::Display for JsonBlobsError {
 3364   3104   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3365   3105   
        match &self {
 3366         -
            EndpointOperationError::InternalServerError(_inner) => _inner.fmt(f),
        3106  +
            JsonBlobsError::InternalServerError(_inner) => _inner.fmt(f),
 3367   3107   
        }
 3368   3108   
    }
 3369   3109   
}
 3370         -
impl EndpointOperationError {
 3371         -
    /// Returns `true` if the error kind is `EndpointOperationError::InternalServerError`.
        3110  +
impl JsonBlobsError {
        3111  +
    /// Returns `true` if the error kind is `JsonBlobsError::InternalServerError`.
 3372   3112   
    pub fn is_internal_server_error(&self) -> bool {
 3373         -
        matches!(&self, EndpointOperationError::InternalServerError(_))
        3113  +
        matches!(&self, JsonBlobsError::InternalServerError(_))
 3374   3114   
    }
 3375   3115   
    /// Returns the error name string by matching the correct variant.
 3376   3116   
    pub fn name(&self) -> &'static str {
 3377   3117   
        match &self {
 3378         -
            EndpointOperationError::InternalServerError(_inner) => _inner.name(),
        3118  +
            JsonBlobsError::InternalServerError(_inner) => _inner.name(),
 3379   3119   
        }
 3380   3120   
    }
 3381   3121   
}
 3382         -
impl ::std::error::Error for EndpointOperationError {
        3122  +
impl ::std::error::Error for JsonBlobsError {
 3383   3123   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3384   3124   
        match &self {
 3385         -
            EndpointOperationError::InternalServerError(_inner) => Some(_inner),
        3125  +
            JsonBlobsError::InternalServerError(_inner) => Some(_inner),
 3386   3126   
        }
 3387   3127   
    }
 3388   3128   
}
 3389         -
impl ::std::convert::From<crate::error::InternalServerError>
 3390         -
    for crate::error::EndpointOperationError
 3391         -
{
 3392         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::EndpointOperationError {
        3129  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonBlobsError {
        3130  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonBlobsError {
 3393   3131   
        Self::InternalServerError(variant)
 3394   3132   
    }
 3395   3133   
}
 3396   3134   
 3397         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::EndpointOperationError {
 3398         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::EndpointOperationError {
        3135  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonBlobsError {
        3136  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonBlobsError {
 3399   3137   
        ::pyo3::Python::with_gil(|py| {
 3400   3138   
            let error = variant.value(py);
 3401   3139   
 3402   3140   
            crate::error::InternalServerError {
 3403   3141   
                message: error.to_string(),
 3404   3142   
            }
 3405   3143   
            .into()
 3406   3144   
        })
 3407   3145   
    }
 3408   3146   
}
 3409   3147   
 3410         -
/// Error type for the `PostUnionWithJsonName` operation.
 3411         -
/// Each variant represents an error that can occur for the `PostUnionWithJsonName` operation.
        3148  +
/// Error type for the `DocumentType` operation.
        3149  +
/// Each variant represents an error that can occur for the `DocumentType` operation.
 3412   3150   
#[derive(::std::fmt::Debug)]
 3413         -
pub enum PostUnionWithJsonNameError {
        3151  +
pub enum DocumentTypeError {
 3414   3152   
    #[allow(missing_docs)] // documentation missing in model
 3415   3153   
    InternalServerError(crate::error::InternalServerError),
 3416   3154   
}
 3417         -
impl ::std::fmt::Display for PostUnionWithJsonNameError {
        3155  +
impl ::std::fmt::Display for DocumentTypeError {
 3418   3156   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3419   3157   
        match &self {
 3420         -
            PostUnionWithJsonNameError::InternalServerError(_inner) => _inner.fmt(f),
        3158  +
            DocumentTypeError::InternalServerError(_inner) => _inner.fmt(f),
 3421   3159   
        }
 3422   3160   
    }
 3423   3161   
}
 3424         -
impl PostUnionWithJsonNameError {
 3425         -
    /// Returns `true` if the error kind is `PostUnionWithJsonNameError::InternalServerError`.
        3162  +
impl DocumentTypeError {
        3163  +
    /// Returns `true` if the error kind is `DocumentTypeError::InternalServerError`.
 3426   3164   
    pub fn is_internal_server_error(&self) -> bool {
 3427         -
        matches!(&self, PostUnionWithJsonNameError::InternalServerError(_))
        3165  +
        matches!(&self, DocumentTypeError::InternalServerError(_))
 3428   3166   
    }
 3429   3167   
    /// Returns the error name string by matching the correct variant.
 3430   3168   
    pub fn name(&self) -> &'static str {
 3431   3169   
        match &self {
 3432         -
            PostUnionWithJsonNameError::InternalServerError(_inner) => _inner.name(),
        3170  +
            DocumentTypeError::InternalServerError(_inner) => _inner.name(),
 3433   3171   
        }
 3434   3172   
    }
 3435   3173   
}
 3436         -
impl ::std::error::Error for PostUnionWithJsonNameError {
        3174  +
impl ::std::error::Error for DocumentTypeError {
 3437   3175   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3438   3176   
        match &self {
 3439         -
            PostUnionWithJsonNameError::InternalServerError(_inner) => Some(_inner),
        3177  +
            DocumentTypeError::InternalServerError(_inner) => Some(_inner),
        3178  +
        }
        3179  +
    }
        3180  +
}
        3181  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::DocumentTypeError {
        3182  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::DocumentTypeError {
        3183  +
        Self::InternalServerError(variant)
        3184  +
    }
        3185  +
}
        3186  +
        3187  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DocumentTypeError {
        3188  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::DocumentTypeError {
        3189  +
        ::pyo3::Python::with_gil(|py| {
        3190  +
            let error = variant.value(py);
        3191  +
        3192  +
            crate::error::InternalServerError {
        3193  +
                message: error.to_string(),
        3194  +
            }
        3195  +
            .into()
        3196  +
        })
        3197  +
    }
        3198  +
}
        3199  +
        3200  +
/// Error type for the `DocumentTypeAsPayload` operation.
        3201  +
/// Each variant represents an error that can occur for the `DocumentTypeAsPayload` operation.
        3202  +
#[derive(::std::fmt::Debug)]
        3203  +
pub enum DocumentTypeAsPayloadError {
        3204  +
    #[allow(missing_docs)] // documentation missing in model
        3205  +
    InternalServerError(crate::error::InternalServerError),
        3206  +
}
        3207  +
impl ::std::fmt::Display for DocumentTypeAsPayloadError {
        3208  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        3209  +
        match &self {
        3210  +
            DocumentTypeAsPayloadError::InternalServerError(_inner) => _inner.fmt(f),
        3211  +
        }
        3212  +
    }
        3213  +
}
        3214  +
impl DocumentTypeAsPayloadError {
        3215  +
    /// Returns `true` if the error kind is `DocumentTypeAsPayloadError::InternalServerError`.
        3216  +
    pub fn is_internal_server_error(&self) -> bool {
        3217  +
        matches!(&self, DocumentTypeAsPayloadError::InternalServerError(_))
        3218  +
    }
        3219  +
    /// Returns the error name string by matching the correct variant.
        3220  +
    pub fn name(&self) -> &'static str {
        3221  +
        match &self {
        3222  +
            DocumentTypeAsPayloadError::InternalServerError(_inner) => _inner.name(),
        3223  +
        }
        3224  +
    }
        3225  +
}
        3226  +
impl ::std::error::Error for DocumentTypeAsPayloadError {
        3227  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        3228  +
        match &self {
        3229  +
            DocumentTypeAsPayloadError::InternalServerError(_inner) => Some(_inner),
 3440   3230   
        }
 3441   3231   
    }
 3442   3232   
}
 3443   3233   
impl ::std::convert::From<crate::error::InternalServerError>
 3444         -
    for crate::error::PostUnionWithJsonNameError
        3234  +
    for crate::error::DocumentTypeAsPayloadError
 3445   3235   
{
 3446   3236   
    fn from(
 3447   3237   
        variant: crate::error::InternalServerError,
 3448         -
    ) -> crate::error::PostUnionWithJsonNameError {
        3238  +
    ) -> crate::error::DocumentTypeAsPayloadError {
 3449   3239   
        Self::InternalServerError(variant)
 3450   3240   
    }
 3451   3241   
}
 3452   3242   
 3453         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::PostUnionWithJsonNameError {
 3454         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::PostUnionWithJsonNameError {
        3243  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DocumentTypeAsPayloadError {
        3244  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::DocumentTypeAsPayloadError {
 3455   3245   
        ::pyo3::Python::with_gil(|py| {
 3456   3246   
            let error = variant.value(py);
 3457   3247   
 3458   3248   
            crate::error::InternalServerError {
 3459   3249   
                message: error.to_string(),
 3460   3250   
            }
 3461   3251   
            .into()
 3462   3252   
        })
 3463   3253   
    }
 3464   3254   
}
 3465   3255   
 3466         -
/// Error type for the `PostPlayerAction` operation.
 3467         -
/// Each variant represents an error that can occur for the `PostPlayerAction` operation.
        3256  +
/// Error type for the `DocumentTypeAsMapValue` operation.
        3257  +
/// Each variant represents an error that can occur for the `DocumentTypeAsMapValue` operation.
 3468   3258   
#[derive(::std::fmt::Debug)]
 3469         -
pub enum PostPlayerActionError {
        3259  +
pub enum DocumentTypeAsMapValueError {
 3470   3260   
    #[allow(missing_docs)] // documentation missing in model
 3471   3261   
    InternalServerError(crate::error::InternalServerError),
 3472   3262   
}
 3473         -
impl ::std::fmt::Display for PostPlayerActionError {
        3263  +
impl ::std::fmt::Display for DocumentTypeAsMapValueError {
 3474   3264   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3475   3265   
        match &self {
 3476         -
            PostPlayerActionError::InternalServerError(_inner) => _inner.fmt(f),
        3266  +
            DocumentTypeAsMapValueError::InternalServerError(_inner) => _inner.fmt(f),
 3477   3267   
        }
 3478   3268   
    }
 3479   3269   
}
 3480         -
impl PostPlayerActionError {
 3481         -
    /// Returns `true` if the error kind is `PostPlayerActionError::InternalServerError`.
        3270  +
impl DocumentTypeAsMapValueError {
        3271  +
    /// Returns `true` if the error kind is `DocumentTypeAsMapValueError::InternalServerError`.
 3482   3272   
    pub fn is_internal_server_error(&self) -> bool {
 3483         -
        matches!(&self, PostPlayerActionError::InternalServerError(_))
        3273  +
        matches!(&self, DocumentTypeAsMapValueError::InternalServerError(_))
 3484   3274   
    }
 3485   3275   
    /// Returns the error name string by matching the correct variant.
 3486   3276   
    pub fn name(&self) -> &'static str {
 3487   3277   
        match &self {
 3488         -
            PostPlayerActionError::InternalServerError(_inner) => _inner.name(),
        3278  +
            DocumentTypeAsMapValueError::InternalServerError(_inner) => _inner.name(),
 3489   3279   
        }
 3490   3280   
    }
 3491   3281   
}
 3492         -
impl ::std::error::Error for PostPlayerActionError {
        3282  +
impl ::std::error::Error for DocumentTypeAsMapValueError {
 3493   3283   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3494   3284   
        match &self {
 3495         -
            PostPlayerActionError::InternalServerError(_inner) => Some(_inner),
        3285  +
            DocumentTypeAsMapValueError::InternalServerError(_inner) => Some(_inner),
 3496   3286   
        }
 3497   3287   
    }
 3498   3288   
}
 3499   3289   
impl ::std::convert::From<crate::error::InternalServerError>
 3500         -
    for crate::error::PostPlayerActionError
        3290  +
    for crate::error::DocumentTypeAsMapValueError
 3501   3291   
{
 3502         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::PostPlayerActionError {
        3292  +
    fn from(
        3293  +
        variant: crate::error::InternalServerError,
        3294  +
    ) -> crate::error::DocumentTypeAsMapValueError {
 3503   3295   
        Self::InternalServerError(variant)
 3504   3296   
    }
 3505   3297   
}
 3506   3298   
 3507         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::PostPlayerActionError {
 3508         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::PostPlayerActionError {
        3299  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DocumentTypeAsMapValueError {
        3300  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::DocumentTypeAsMapValueError {
 3509   3301   
        ::pyo3::Python::with_gil(|py| {
 3510   3302   
            let error = variant.value(py);
 3511   3303   
 3512   3304   
            crate::error::InternalServerError {
 3513   3305   
                message: error.to_string(),
 3514   3306   
            }
 3515   3307   
            .into()
 3516   3308   
        })
 3517   3309   
    }
 3518   3310   
}
@@ -3558,3350 +7046,7959 @@
 3578   3370   
                return error.into();
 3579   3371   
            }
 3580   3372   
            crate::error::InternalServerError {
 3581   3373   
                message: error.to_string(),
 3582   3374   
            }
 3583   3375   
            .into()
 3584   3376   
        })
 3585   3377   
    }
 3586   3378   
}
 3587   3379   
 3588         -
/// Error type for the `DocumentTypeAsMapValue` operation.
 3589         -
/// Each variant represents an error that can occur for the `DocumentTypeAsMapValue` operation.
        3380  +
/// Error type for the `PostPlayerAction` operation.
        3381  +
/// Each variant represents an error that can occur for the `PostPlayerAction` operation.
 3590   3382   
#[derive(::std::fmt::Debug)]
 3591         -
pub enum DocumentTypeAsMapValueError {
        3383  +
pub enum PostPlayerActionError {
 3592   3384   
    #[allow(missing_docs)] // documentation missing in model
 3593   3385   
    InternalServerError(crate::error::InternalServerError),
 3594   3386   
}
 3595         -
impl ::std::fmt::Display for DocumentTypeAsMapValueError {
        3387  +
impl ::std::fmt::Display for PostPlayerActionError {
 3596   3388   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3597   3389   
        match &self {
 3598         -
            DocumentTypeAsMapValueError::InternalServerError(_inner) => _inner.fmt(f),
        3390  +
            PostPlayerActionError::InternalServerError(_inner) => _inner.fmt(f),
 3599   3391   
        }
 3600   3392   
    }
 3601   3393   
}
 3602         -
impl DocumentTypeAsMapValueError {
 3603         -
    /// Returns `true` if the error kind is `DocumentTypeAsMapValueError::InternalServerError`.
        3394  +
impl PostPlayerActionError {
        3395  +
    /// Returns `true` if the error kind is `PostPlayerActionError::InternalServerError`.
 3604   3396   
    pub fn is_internal_server_error(&self) -> bool {
 3605         -
        matches!(&self, DocumentTypeAsMapValueError::InternalServerError(_))
        3397  +
        matches!(&self, PostPlayerActionError::InternalServerError(_))
 3606   3398   
    }
 3607   3399   
    /// Returns the error name string by matching the correct variant.
 3608   3400   
    pub fn name(&self) -> &'static str {
 3609   3401   
        match &self {
 3610         -
            DocumentTypeAsMapValueError::InternalServerError(_inner) => _inner.name(),
        3402  +
            PostPlayerActionError::InternalServerError(_inner) => _inner.name(),
 3611   3403   
        }
 3612   3404   
    }
 3613   3405   
}
 3614         -
impl ::std::error::Error for DocumentTypeAsMapValueError {
        3406  +
impl ::std::error::Error for PostPlayerActionError {
 3615   3407   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3616   3408   
        match &self {
 3617         -
            DocumentTypeAsMapValueError::InternalServerError(_inner) => Some(_inner),
        3409  +
            PostPlayerActionError::InternalServerError(_inner) => Some(_inner),
 3618   3410   
        }
 3619   3411   
    }
 3620   3412   
}
 3621   3413   
impl ::std::convert::From<crate::error::InternalServerError>
 3622         -
    for crate::error::DocumentTypeAsMapValueError
        3414  +
    for crate::error::PostPlayerActionError
 3623   3415   
{
 3624         -
    fn from(
 3625         -
        variant: crate::error::InternalServerError,
 3626         -
    ) -> crate::error::DocumentTypeAsMapValueError {
        3416  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::PostPlayerActionError {
 3627   3417   
        Self::InternalServerError(variant)
 3628   3418   
    }
 3629   3419   
}
 3630   3420   
 3631         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DocumentTypeAsMapValueError {
 3632         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::DocumentTypeAsMapValueError {
        3421  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::PostPlayerActionError {
        3422  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::PostPlayerActionError {
 3633   3423   
        ::pyo3::Python::with_gil(|py| {
 3634   3424   
            let error = variant.value(py);
 3635   3425   
 3636   3426   
            crate::error::InternalServerError {
 3637   3427   
                message: error.to_string(),
 3638   3428   
            }
 3639   3429   
            .into()
 3640   3430   
        })
 3641   3431   
    }
 3642   3432   
}
 3643   3433   
 3644         -
/// Error type for the `DocumentTypeAsPayload` operation.
 3645         -
/// Each variant represents an error that can occur for the `DocumentTypeAsPayload` operation.
        3434  +
/// Error type for the `PostUnionWithJsonName` operation.
        3435  +
/// Each variant represents an error that can occur for the `PostUnionWithJsonName` operation.
 3646   3436   
#[derive(::std::fmt::Debug)]
 3647         -
pub enum DocumentTypeAsPayloadError {
        3437  +
pub enum PostUnionWithJsonNameError {
 3648   3438   
    #[allow(missing_docs)] // documentation missing in model
 3649   3439   
    InternalServerError(crate::error::InternalServerError),
 3650   3440   
}
 3651         -
impl ::std::fmt::Display for DocumentTypeAsPayloadError {
        3441  +
impl ::std::fmt::Display for PostUnionWithJsonNameError {
 3652   3442   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3653   3443   
        match &self {
 3654         -
            DocumentTypeAsPayloadError::InternalServerError(_inner) => _inner.fmt(f),
        3444  +
            PostUnionWithJsonNameError::InternalServerError(_inner) => _inner.fmt(f),
 3655   3445   
        }
 3656   3446   
    }
 3657   3447   
}
 3658         -
impl DocumentTypeAsPayloadError {
 3659         -
    /// Returns `true` if the error kind is `DocumentTypeAsPayloadError::InternalServerError`.
        3448  +
impl PostUnionWithJsonNameError {
        3449  +
    /// Returns `true` if the error kind is `PostUnionWithJsonNameError::InternalServerError`.
 3660   3450   
    pub fn is_internal_server_error(&self) -> bool {
 3661         -
        matches!(&self, DocumentTypeAsPayloadError::InternalServerError(_))
        3451  +
        matches!(&self, PostUnionWithJsonNameError::InternalServerError(_))
 3662   3452   
    }
 3663   3453   
    /// Returns the error name string by matching the correct variant.
 3664   3454   
    pub fn name(&self) -> &'static str {
 3665   3455   
        match &self {
 3666         -
            DocumentTypeAsPayloadError::InternalServerError(_inner) => _inner.name(),
        3456  +
            PostUnionWithJsonNameError::InternalServerError(_inner) => _inner.name(),
 3667   3457   
        }
 3668   3458   
    }
 3669   3459   
}
 3670         -
impl ::std::error::Error for DocumentTypeAsPayloadError {
        3460  +
impl ::std::error::Error for PostUnionWithJsonNameError {
 3671   3461   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3672   3462   
        match &self {
 3673         -
            DocumentTypeAsPayloadError::InternalServerError(_inner) => Some(_inner),
        3463  +
            PostUnionWithJsonNameError::InternalServerError(_inner) => Some(_inner),
 3674   3464   
        }
 3675   3465   
    }
 3676   3466   
}
 3677   3467   
impl ::std::convert::From<crate::error::InternalServerError>
 3678         -
    for crate::error::DocumentTypeAsPayloadError
        3468  +
    for crate::error::PostUnionWithJsonNameError
 3679   3469   
{
 3680   3470   
    fn from(
 3681   3471   
        variant: crate::error::InternalServerError,
 3682         -
    ) -> crate::error::DocumentTypeAsPayloadError {
        3472  +
    ) -> crate::error::PostUnionWithJsonNameError {
 3683   3473   
        Self::InternalServerError(variant)
 3684   3474   
    }
 3685   3475   
}
 3686   3476   
 3687         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DocumentTypeAsPayloadError {
 3688         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::DocumentTypeAsPayloadError {
        3477  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::PostUnionWithJsonNameError {
        3478  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::PostUnionWithJsonNameError {
 3689   3479   
        ::pyo3::Python::with_gil(|py| {
 3690   3480   
            let error = variant.value(py);
 3691   3481   
 3692   3482   
            crate::error::InternalServerError {
 3693   3483   
                message: error.to_string(),
 3694   3484   
            }
 3695   3485   
            .into()
 3696   3486   
        })
 3697   3487   
    }
 3698   3488   
}
 3699   3489   
 3700         -
/// Error type for the `DocumentType` operation.
 3701         -
/// Each variant represents an error that can occur for the `DocumentType` operation.
        3490  +
/// Error type for the `EndpointOperation` operation.
        3491  +
/// Each variant represents an error that can occur for the `EndpointOperation` operation.
 3702   3492   
#[derive(::std::fmt::Debug)]
 3703         -
pub enum DocumentTypeError {
        3493  +
pub enum EndpointOperationError {
 3704   3494   
    #[allow(missing_docs)] // documentation missing in model
 3705   3495   
    InternalServerError(crate::error::InternalServerError),
 3706   3496   
}
 3707         -
impl ::std::fmt::Display for DocumentTypeError {
        3497  +
impl ::std::fmt::Display for EndpointOperationError {
 3708   3498   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3709   3499   
        match &self {
 3710         -
            DocumentTypeError::InternalServerError(_inner) => _inner.fmt(f),
        3500  +
            EndpointOperationError::InternalServerError(_inner) => _inner.fmt(f),
 3711   3501   
        }
 3712   3502   
    }
 3713   3503   
}
 3714         -
impl DocumentTypeError {
 3715         -
    /// Returns `true` if the error kind is `DocumentTypeError::InternalServerError`.
        3504  +
impl EndpointOperationError {
        3505  +
    /// Returns `true` if the error kind is `EndpointOperationError::InternalServerError`.
 3716   3506   
    pub fn is_internal_server_error(&self) -> bool {
 3717         -
        matches!(&self, DocumentTypeError::InternalServerError(_))
        3507  +
        matches!(&self, EndpointOperationError::InternalServerError(_))
 3718   3508   
    }
 3719   3509   
    /// Returns the error name string by matching the correct variant.
 3720   3510   
    pub fn name(&self) -> &'static str {
 3721   3511   
        match &self {
 3722         -
            DocumentTypeError::InternalServerError(_inner) => _inner.name(),
        3512  +
            EndpointOperationError::InternalServerError(_inner) => _inner.name(),
 3723   3513   
        }
 3724   3514   
    }
 3725   3515   
}
 3726         -
impl ::std::error::Error for DocumentTypeError {
        3516  +
impl ::std::error::Error for EndpointOperationError {
 3727   3517   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3728   3518   
        match &self {
 3729         -
            DocumentTypeError::InternalServerError(_inner) => Some(_inner),
        3519  +
            EndpointOperationError::InternalServerError(_inner) => Some(_inner),
 3730   3520   
        }
 3731   3521   
    }
 3732   3522   
}
 3733         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::DocumentTypeError {
 3734         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::DocumentTypeError {
        3523  +
impl ::std::convert::From<crate::error::InternalServerError>
        3524  +
    for crate::error::EndpointOperationError
        3525  +
{
        3526  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::EndpointOperationError {
 3735   3527   
        Self::InternalServerError(variant)
 3736   3528   
    }
 3737   3529   
}
 3738   3530   
 3739         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DocumentTypeError {
 3740         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::DocumentTypeError {
        3531  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::EndpointOperationError {
        3532  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::EndpointOperationError {
 3741   3533   
        ::pyo3::Python::with_gil(|py| {
 3742   3534   
            let error = variant.value(py);
 3743   3535   
 3744   3536   
            crate::error::InternalServerError {
 3745   3537   
                message: error.to_string(),
 3746   3538   
            }
 3747   3539   
            .into()
 3748   3540   
        })
 3749   3541   
    }
 3750   3542   
}
 3751   3543   
 3752         -
/// Error type for the `JsonBlobs` operation.
 3753         -
/// Each variant represents an error that can occur for the `JsonBlobs` operation.
        3544  +
/// Error type for the `EndpointWithHostLabelOperation` operation.
        3545  +
/// Each variant represents an error that can occur for the `EndpointWithHostLabelOperation` operation.
 3754   3546   
#[derive(::std::fmt::Debug)]
 3755         -
pub enum JsonBlobsError {
        3547  +
pub enum EndpointWithHostLabelOperationError {
        3548  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        3549  +
    ValidationException(crate::error::ValidationException),
 3756   3550   
    #[allow(missing_docs)] // documentation missing in model
 3757   3551   
    InternalServerError(crate::error::InternalServerError),
 3758   3552   
}
 3759         -
impl ::std::fmt::Display for JsonBlobsError {
        3553  +
impl ::std::fmt::Display for EndpointWithHostLabelOperationError {
 3760   3554   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3761   3555   
        match &self {
 3762         -
            JsonBlobsError::InternalServerError(_inner) => _inner.fmt(f),
        3556  +
            EndpointWithHostLabelOperationError::ValidationException(_inner) => _inner.fmt(f),
        3557  +
            EndpointWithHostLabelOperationError::InternalServerError(_inner) => _inner.fmt(f),
 3763   3558   
        }
 3764   3559   
    }
 3765   3560   
}
 3766         -
impl JsonBlobsError {
 3767         -
    /// Returns `true` if the error kind is `JsonBlobsError::InternalServerError`.
        3561  +
impl EndpointWithHostLabelOperationError {
        3562  +
    /// Returns `true` if the error kind is `EndpointWithHostLabelOperationError::ValidationException`.
        3563  +
    pub fn is_validation_exception(&self) -> bool {
        3564  +
        matches!(
        3565  +
            &self,
        3566  +
            EndpointWithHostLabelOperationError::ValidationException(_)
        3567  +
        )
        3568  +
    }
        3569  +
    /// Returns `true` if the error kind is `EndpointWithHostLabelOperationError::InternalServerError`.
 3768   3570   
    pub fn is_internal_server_error(&self) -> bool {
 3769         -
        matches!(&self, JsonBlobsError::InternalServerError(_))
        3571  +
        matches!(
        3572  +
            &self,
        3573  +
            EndpointWithHostLabelOperationError::InternalServerError(_)
        3574  +
        )
 3770   3575   
    }
 3771   3576   
    /// Returns the error name string by matching the correct variant.
 3772   3577   
    pub fn name(&self) -> &'static str {
 3773   3578   
        match &self {
 3774         -
            JsonBlobsError::InternalServerError(_inner) => _inner.name(),
        3579  +
            EndpointWithHostLabelOperationError::ValidationException(_inner) => _inner.name(),
        3580  +
            EndpointWithHostLabelOperationError::InternalServerError(_inner) => _inner.name(),
 3775   3581   
        }
 3776   3582   
    }
 3777   3583   
}
 3778         -
impl ::std::error::Error for JsonBlobsError {
        3584  +
impl ::std::error::Error for EndpointWithHostLabelOperationError {
 3779   3585   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3780   3586   
        match &self {
 3781         -
            JsonBlobsError::InternalServerError(_inner) => Some(_inner),
        3587  +
            EndpointWithHostLabelOperationError::ValidationException(_inner) => Some(_inner),
        3588  +
            EndpointWithHostLabelOperationError::InternalServerError(_inner) => Some(_inner),
 3782   3589   
        }
 3783   3590   
    }
 3784   3591   
}
 3785         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonBlobsError {
 3786         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonBlobsError {
        3592  +
impl ::std::convert::From<crate::error::ValidationException>
        3593  +
    for crate::error::EndpointWithHostLabelOperationError
        3594  +
{
        3595  +
    fn from(
        3596  +
        variant: crate::error::ValidationException,
        3597  +
    ) -> crate::error::EndpointWithHostLabelOperationError {
        3598  +
        Self::ValidationException(variant)
        3599  +
    }
        3600  +
}
        3601  +
impl ::std::convert::From<crate::error::InternalServerError>
        3602  +
    for crate::error::EndpointWithHostLabelOperationError
        3603  +
{
        3604  +
    fn from(
        3605  +
        variant: crate::error::InternalServerError,
        3606  +
    ) -> crate::error::EndpointWithHostLabelOperationError {
 3787   3607   
        Self::InternalServerError(variant)
 3788   3608   
    }
 3789   3609   
}
 3790   3610   
 3791         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonBlobsError {
 3792         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonBlobsError {
        3611  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::EndpointWithHostLabelOperationError {
        3612  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::EndpointWithHostLabelOperationError {
 3793   3613   
        ::pyo3::Python::with_gil(|py| {
 3794   3614   
            let error = variant.value(py);
 3795         -
        3615  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        3616  +
                return error.into();
        3617  +
            }
 3796   3618   
            crate::error::InternalServerError {
 3797   3619   
                message: error.to_string(),
 3798   3620   
            }
 3799   3621   
            .into()
 3800   3622   
        })
 3801   3623   
    }
 3802   3624   
}
 3803   3625   
 3804         -
/// Error type for the `SparseJsonMaps` operation.
 3805         -
/// Each variant represents an error that can occur for the `SparseJsonMaps` operation.
        3626  +
/// Error type for the `HostWithPathOperation` operation.
        3627  +
/// Each variant represents an error that can occur for the `HostWithPathOperation` operation.
 3806   3628   
#[derive(::std::fmt::Debug)]
 3807         -
pub enum SparseJsonMapsError {
 3808         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 3809         -
    ValidationException(crate::error::ValidationException),
        3629  +
pub enum HostWithPathOperationError {
 3810   3630   
    #[allow(missing_docs)] // documentation missing in model
 3811   3631   
    InternalServerError(crate::error::InternalServerError),
 3812   3632   
}
 3813         -
impl ::std::fmt::Display for SparseJsonMapsError {
        3633  +
impl ::std::fmt::Display for HostWithPathOperationError {
 3814   3634   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3815   3635   
        match &self {
 3816         -
            SparseJsonMapsError::ValidationException(_inner) => _inner.fmt(f),
 3817         -
            SparseJsonMapsError::InternalServerError(_inner) => _inner.fmt(f),
        3636  +
            HostWithPathOperationError::InternalServerError(_inner) => _inner.fmt(f),
 3818   3637   
        }
 3819   3638   
    }
 3820   3639   
}
 3821         -
impl SparseJsonMapsError {
 3822         -
    /// Returns `true` if the error kind is `SparseJsonMapsError::ValidationException`.
 3823         -
    pub fn is_validation_exception(&self) -> bool {
 3824         -
        matches!(&self, SparseJsonMapsError::ValidationException(_))
 3825         -
    }
 3826         -
    /// Returns `true` if the error kind is `SparseJsonMapsError::InternalServerError`.
        3640  +
impl HostWithPathOperationError {
        3641  +
    /// Returns `true` if the error kind is `HostWithPathOperationError::InternalServerError`.
 3827   3642   
    pub fn is_internal_server_error(&self) -> bool {
 3828         -
        matches!(&self, SparseJsonMapsError::InternalServerError(_))
        3643  +
        matches!(&self, HostWithPathOperationError::InternalServerError(_))
 3829   3644   
    }
 3830   3645   
    /// Returns the error name string by matching the correct variant.
 3831   3646   
    pub fn name(&self) -> &'static str {
 3832   3647   
        match &self {
 3833         -
            SparseJsonMapsError::ValidationException(_inner) => _inner.name(),
 3834         -
            SparseJsonMapsError::InternalServerError(_inner) => _inner.name(),
        3648  +
            HostWithPathOperationError::InternalServerError(_inner) => _inner.name(),
 3835   3649   
        }
 3836   3650   
    }
 3837   3651   
}
 3838         -
impl ::std::error::Error for SparseJsonMapsError {
        3652  +
impl ::std::error::Error for HostWithPathOperationError {
 3839   3653   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3840   3654   
        match &self {
 3841         -
            SparseJsonMapsError::ValidationException(_inner) => Some(_inner),
 3842         -
            SparseJsonMapsError::InternalServerError(_inner) => Some(_inner),
        3655  +
            HostWithPathOperationError::InternalServerError(_inner) => Some(_inner),
 3843   3656   
        }
 3844   3657   
    }
 3845   3658   
}
 3846         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::SparseJsonMapsError {
 3847         -
    fn from(variant: crate::error::ValidationException) -> crate::error::SparseJsonMapsError {
 3848         -
        Self::ValidationException(variant)
 3849         -
    }
 3850         -
}
 3851         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::SparseJsonMapsError {
 3852         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::SparseJsonMapsError {
        3659  +
impl ::std::convert::From<crate::error::InternalServerError>
        3660  +
    for crate::error::HostWithPathOperationError
        3661  +
{
        3662  +
    fn from(
        3663  +
        variant: crate::error::InternalServerError,
        3664  +
    ) -> crate::error::HostWithPathOperationError {
 3853   3665   
        Self::InternalServerError(variant)
 3854   3666   
    }
 3855   3667   
}
 3856   3668   
 3857         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::SparseJsonMapsError {
 3858         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::SparseJsonMapsError {
        3669  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HostWithPathOperationError {
        3670  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HostWithPathOperationError {
 3859   3671   
        ::pyo3::Python::with_gil(|py| {
 3860   3672   
            let error = variant.value(py);
 3861         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 3862         -
                return error.into();
 3863         -
            }
        3673  +
 3864   3674   
            crate::error::InternalServerError {
 3865   3675   
                message: error.to_string(),
 3866   3676   
            }
 3867   3677   
            .into()
 3868   3678   
        })
 3869   3679   
    }
 3870   3680   
}
 3871   3681   
 3872         -
/// Error type for the `JsonMaps` operation.
 3873         -
/// Each variant represents an error that can occur for the `JsonMaps` operation.
        3682  +
/// Error type for the `HttpChecksumRequired` operation.
        3683  +
/// Each variant represents an error that can occur for the `HttpChecksumRequired` operation.
 3874   3684   
#[derive(::std::fmt::Debug)]
 3875         -
pub enum JsonMapsError {
 3876         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 3877         -
    ValidationException(crate::error::ValidationException),
        3685  +
pub enum HttpChecksumRequiredError {
 3878   3686   
    #[allow(missing_docs)] // documentation missing in model
 3879   3687   
    InternalServerError(crate::error::InternalServerError),
 3880   3688   
}
 3881         -
impl ::std::fmt::Display for JsonMapsError {
        3689  +
impl ::std::fmt::Display for HttpChecksumRequiredError {
 3882   3690   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3883   3691   
        match &self {
 3884         -
            JsonMapsError::ValidationException(_inner) => _inner.fmt(f),
 3885         -
            JsonMapsError::InternalServerError(_inner) => _inner.fmt(f),
        3692  +
            HttpChecksumRequiredError::InternalServerError(_inner) => _inner.fmt(f),
 3886   3693   
        }
 3887   3694   
    }
 3888   3695   
}
 3889         -
impl JsonMapsError {
 3890         -
    /// Returns `true` if the error kind is `JsonMapsError::ValidationException`.
 3891         -
    pub fn is_validation_exception(&self) -> bool {
 3892         -
        matches!(&self, JsonMapsError::ValidationException(_))
 3893         -
    }
 3894         -
    /// Returns `true` if the error kind is `JsonMapsError::InternalServerError`.
        3696  +
impl HttpChecksumRequiredError {
        3697  +
    /// Returns `true` if the error kind is `HttpChecksumRequiredError::InternalServerError`.
 3895   3698   
    pub fn is_internal_server_error(&self) -> bool {
 3896         -
        matches!(&self, JsonMapsError::InternalServerError(_))
        3699  +
        matches!(&self, HttpChecksumRequiredError::InternalServerError(_))
 3897   3700   
    }
 3898   3701   
    /// Returns the error name string by matching the correct variant.
 3899   3702   
    pub fn name(&self) -> &'static str {
 3900   3703   
        match &self {
 3901         -
            JsonMapsError::ValidationException(_inner) => _inner.name(),
 3902         -
            JsonMapsError::InternalServerError(_inner) => _inner.name(),
        3704  +
            HttpChecksumRequiredError::InternalServerError(_inner) => _inner.name(),
 3903   3705   
        }
 3904   3706   
    }
 3905   3707   
}
 3906         -
impl ::std::error::Error for JsonMapsError {
        3708  +
impl ::std::error::Error for HttpChecksumRequiredError {
 3907   3709   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3908   3710   
        match &self {
 3909         -
            JsonMapsError::ValidationException(_inner) => Some(_inner),
 3910         -
            JsonMapsError::InternalServerError(_inner) => Some(_inner),
        3711  +
            HttpChecksumRequiredError::InternalServerError(_inner) => Some(_inner),
 3911   3712   
        }
 3912   3713   
    }
 3913   3714   
}
 3914         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonMapsError {
 3915         -
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonMapsError {
 3916         -
        Self::ValidationException(variant)
 3917         -
    }
 3918         -
}
 3919         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonMapsError {
 3920         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonMapsError {
        3715  +
impl ::std::convert::From<crate::error::InternalServerError>
        3716  +
    for crate::error::HttpChecksumRequiredError
        3717  +
{
        3718  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpChecksumRequiredError {
 3921   3719   
        Self::InternalServerError(variant)
 3922   3720   
    }
 3923   3721   
}
 3924   3722   
 3925         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonMapsError {
 3926         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonMapsError {
        3723  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpChecksumRequiredError {
        3724  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpChecksumRequiredError {
 3927   3725   
        ::pyo3::Python::with_gil(|py| {
 3928   3726   
            let error = variant.value(py);
 3929         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 3930         -
                return error.into();
 3931         -
            }
        3727  +
 3932   3728   
            crate::error::InternalServerError {
 3933   3729   
                message: error.to_string(),
 3934   3730   
            }
 3935   3731   
            .into()
 3936   3732   
        })
 3937   3733   
    }
 3938   3734   
}
 3939   3735   
 3940         -
/// Error type for the `SparseJsonLists` operation.
 3941         -
/// Each variant represents an error that can occur for the `SparseJsonLists` operation.
        3736  +
/// Error type for the `MalformedRequestBody` operation.
        3737  +
/// Each variant represents an error that can occur for the `MalformedRequestBody` operation.
 3942   3738   
#[derive(::std::fmt::Debug)]
 3943         -
pub enum SparseJsonListsError {
        3739  +
pub enum MalformedRequestBodyError {
 3944   3740   
    #[allow(missing_docs)] // documentation missing in model
 3945   3741   
    InternalServerError(crate::error::InternalServerError),
 3946   3742   
}
 3947         -
impl ::std::fmt::Display for SparseJsonListsError {
        3743  +
impl ::std::fmt::Display for MalformedRequestBodyError {
 3948   3744   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 3949   3745   
        match &self {
 3950         -
            SparseJsonListsError::InternalServerError(_inner) => _inner.fmt(f),
        3746  +
            MalformedRequestBodyError::InternalServerError(_inner) => _inner.fmt(f),
 3951   3747   
        }
 3952   3748   
    }
 3953   3749   
}
 3954         -
impl SparseJsonListsError {
 3955         -
    /// Returns `true` if the error kind is `SparseJsonListsError::InternalServerError`.
        3750  +
impl MalformedRequestBodyError {
        3751  +
    /// Returns `true` if the error kind is `MalformedRequestBodyError::InternalServerError`.
 3956   3752   
    pub fn is_internal_server_error(&self) -> bool {
 3957         -
        matches!(&self, SparseJsonListsError::InternalServerError(_))
        3753  +
        matches!(&self, MalformedRequestBodyError::InternalServerError(_))
 3958   3754   
    }
 3959   3755   
    /// Returns the error name string by matching the correct variant.
 3960   3756   
    pub fn name(&self) -> &'static str {
 3961   3757   
        match &self {
 3962         -
            SparseJsonListsError::InternalServerError(_inner) => _inner.name(),
        3758  +
            MalformedRequestBodyError::InternalServerError(_inner) => _inner.name(),
 3963   3759   
        }
 3964   3760   
    }
 3965   3761   
}
 3966         -
impl ::std::error::Error for SparseJsonListsError {
        3762  +
impl ::std::error::Error for MalformedRequestBodyError {
 3967   3763   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 3968   3764   
        match &self {
 3969         -
            SparseJsonListsError::InternalServerError(_inner) => Some(_inner),
        3765  +
            MalformedRequestBodyError::InternalServerError(_inner) => Some(_inner),
 3970   3766   
        }
 3971   3767   
    }
 3972   3768   
}
 3973   3769   
impl ::std::convert::From<crate::error::InternalServerError>
 3974         -
    for crate::error::SparseJsonListsError
        3770  +
    for crate::error::MalformedRequestBodyError
 3975   3771   
{
 3976         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::SparseJsonListsError {
        3772  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedRequestBodyError {
 3977   3773   
        Self::InternalServerError(variant)
 3978   3774   
    }
 3979   3775   
}
 3980   3776   
 3981         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::SparseJsonListsError {
 3982         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::SparseJsonListsError {
        3777  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedRequestBodyError {
        3778  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedRequestBodyError {
 3983   3779   
        ::pyo3::Python::with_gil(|py| {
 3984   3780   
            let error = variant.value(py);
 3985   3781   
 3986   3782   
            crate::error::InternalServerError {
 3987   3783   
                message: error.to_string(),
 3988   3784   
            }
 3989   3785   
            .into()
 3990   3786   
        })
 3991   3787   
    }
 3992   3788   
}
 3993   3789   
 3994         -
/// Error type for the `JsonLists` operation.
 3995         -
/// Each variant represents an error that can occur for the `JsonLists` operation.
        3790  +
/// Error type for the `MalformedInteger` operation.
        3791  +
/// Each variant represents an error that can occur for the `MalformedInteger` operation.
 3996   3792   
#[derive(::std::fmt::Debug)]
 3997         -
pub enum JsonListsError {
        3793  +
pub enum MalformedIntegerError {
 3998   3794   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 3999   3795   
    ValidationException(crate::error::ValidationException),
 4000   3796   
    #[allow(missing_docs)] // documentation missing in model
 4001   3797   
    InternalServerError(crate::error::InternalServerError),
 4002   3798   
}
 4003         -
impl ::std::fmt::Display for JsonListsError {
        3799  +
impl ::std::fmt::Display for MalformedIntegerError {
 4004   3800   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4005   3801   
        match &self {
 4006         -
            JsonListsError::ValidationException(_inner) => _inner.fmt(f),
 4007         -
            JsonListsError::InternalServerError(_inner) => _inner.fmt(f),
        3802  +
            MalformedIntegerError::ValidationException(_inner) => _inner.fmt(f),
        3803  +
            MalformedIntegerError::InternalServerError(_inner) => _inner.fmt(f),
 4008   3804   
        }
 4009   3805   
    }
 4010   3806   
}
 4011         -
impl JsonListsError {
 4012         -
    /// Returns `true` if the error kind is `JsonListsError::ValidationException`.
        3807  +
impl MalformedIntegerError {
        3808  +
    /// Returns `true` if the error kind is `MalformedIntegerError::ValidationException`.
 4013   3809   
    pub fn is_validation_exception(&self) -> bool {
 4014         -
        matches!(&self, JsonListsError::ValidationException(_))
        3810  +
        matches!(&self, MalformedIntegerError::ValidationException(_))
 4015   3811   
    }
 4016         -
    /// Returns `true` if the error kind is `JsonListsError::InternalServerError`.
        3812  +
    /// Returns `true` if the error kind is `MalformedIntegerError::InternalServerError`.
 4017   3813   
    pub fn is_internal_server_error(&self) -> bool {
 4018         -
        matches!(&self, JsonListsError::InternalServerError(_))
        3814  +
        matches!(&self, MalformedIntegerError::InternalServerError(_))
 4019   3815   
    }
 4020   3816   
    /// Returns the error name string by matching the correct variant.
 4021   3817   
    pub fn name(&self) -> &'static str {
 4022   3818   
        match &self {
 4023         -
            JsonListsError::ValidationException(_inner) => _inner.name(),
 4024         -
            JsonListsError::InternalServerError(_inner) => _inner.name(),
        3819  +
            MalformedIntegerError::ValidationException(_inner) => _inner.name(),
        3820  +
            MalformedIntegerError::InternalServerError(_inner) => _inner.name(),
 4025   3821   
        }
 4026   3822   
    }
 4027   3823   
}
 4028         -
impl ::std::error::Error for JsonListsError {
        3824  +
impl ::std::error::Error for MalformedIntegerError {
 4029   3825   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4030   3826   
        match &self {
 4031         -
            JsonListsError::ValidationException(_inner) => Some(_inner),
 4032         -
            JsonListsError::InternalServerError(_inner) => Some(_inner),
        3827  +
            MalformedIntegerError::ValidationException(_inner) => Some(_inner),
        3828  +
            MalformedIntegerError::InternalServerError(_inner) => Some(_inner),
 4033   3829   
        }
 4034   3830   
    }
 4035   3831   
}
 4036         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonListsError {
 4037         -
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonListsError {
        3832  +
impl ::std::convert::From<crate::error::ValidationException>
        3833  +
    for crate::error::MalformedIntegerError
        3834  +
{
        3835  +
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedIntegerError {
 4038   3836   
        Self::ValidationException(variant)
 4039   3837   
    }
 4040   3838   
}
 4041         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonListsError {
 4042         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonListsError {
        3839  +
impl ::std::convert::From<crate::error::InternalServerError>
        3840  +
    for crate::error::MalformedIntegerError
        3841  +
{
        3842  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedIntegerError {
 4043   3843   
        Self::InternalServerError(variant)
 4044   3844   
    }
 4045   3845   
}
 4046   3846   
 4047         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonListsError {
 4048         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonListsError {
        3847  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedIntegerError {
        3848  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedIntegerError {
 4049   3849   
        ::pyo3::Python::with_gil(|py| {
 4050   3850   
            let error = variant.value(py);
 4051   3851   
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 4052   3852   
                return error.into();
 4053   3853   
            }
 4054   3854   
            crate::error::InternalServerError {
 4055   3855   
                message: error.to_string(),
 4056   3856   
            }
 4057   3857   
            .into()
 4058   3858   
        })
 4059   3859   
    }
 4060   3860   
}
 4061   3861   
 4062         -
/// Error type for the `RecursiveShapes` operation.
 4063         -
/// Each variant represents an error that can occur for the `RecursiveShapes` operation.
        3862  +
/// Error type for the `MalformedUnion` operation.
        3863  +
/// Each variant represents an error that can occur for the `MalformedUnion` operation.
 4064   3864   
#[derive(::std::fmt::Debug)]
 4065         -
pub enum RecursiveShapesError {
        3865  +
pub enum MalformedUnionError {
 4066   3866   
    #[allow(missing_docs)] // documentation missing in model
 4067   3867   
    InternalServerError(crate::error::InternalServerError),
 4068   3868   
}
 4069         -
impl ::std::fmt::Display for RecursiveShapesError {
        3869  +
impl ::std::fmt::Display for MalformedUnionError {
 4070   3870   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4071   3871   
        match &self {
 4072         -
            RecursiveShapesError::InternalServerError(_inner) => _inner.fmt(f),
        3872  +
            MalformedUnionError::InternalServerError(_inner) => _inner.fmt(f),
 4073   3873   
        }
 4074   3874   
    }
 4075   3875   
}
 4076         -
impl RecursiveShapesError {
 4077         -
    /// Returns `true` if the error kind is `RecursiveShapesError::InternalServerError`.
        3876  +
impl MalformedUnionError {
        3877  +
    /// Returns `true` if the error kind is `MalformedUnionError::InternalServerError`.
 4078   3878   
    pub fn is_internal_server_error(&self) -> bool {
 4079         -
        matches!(&self, RecursiveShapesError::InternalServerError(_))
        3879  +
        matches!(&self, MalformedUnionError::InternalServerError(_))
 4080   3880   
    }
 4081   3881   
    /// Returns the error name string by matching the correct variant.
 4082   3882   
    pub fn name(&self) -> &'static str {
 4083   3883   
        match &self {
 4084         -
            RecursiveShapesError::InternalServerError(_inner) => _inner.name(),
        3884  +
            MalformedUnionError::InternalServerError(_inner) => _inner.name(),
 4085   3885   
        }
 4086   3886   
    }
 4087   3887   
}
 4088         -
impl ::std::error::Error for RecursiveShapesError {
        3888  +
impl ::std::error::Error for MalformedUnionError {
 4089   3889   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4090   3890   
        match &self {
 4091         -
            RecursiveShapesError::InternalServerError(_inner) => Some(_inner),
        3891  +
            MalformedUnionError::InternalServerError(_inner) => Some(_inner),
 4092   3892   
        }
 4093   3893   
    }
 4094   3894   
}
 4095         -
impl ::std::convert::From<crate::error::InternalServerError>
 4096         -
    for crate::error::RecursiveShapesError
 4097         -
{
 4098         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::RecursiveShapesError {
 4099         -
        Self::InternalServerError(variant)
        3895  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedUnionError {
        3896  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedUnionError {
        3897  +
        Self::InternalServerError(variant)
 4100   3898   
    }
 4101   3899   
}
 4102   3900   
 4103         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::RecursiveShapesError {
 4104         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::RecursiveShapesError {
        3901  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedUnionError {
        3902  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedUnionError {
 4105   3903   
        ::pyo3::Python::with_gil(|py| {
 4106   3904   
            let error = variant.value(py);
 4107   3905   
 4108   3906   
            crate::error::InternalServerError {
 4109   3907   
                message: error.to_string(),
 4110   3908   
            }
 4111   3909   
            .into()
 4112   3910   
        })
 4113   3911   
    }
 4114   3912   
}
 4115   3913   
 4116         -
/// Error type for the `JsonIntEnums` operation.
 4117         -
/// Each variant represents an error that can occur for the `JsonIntEnums` operation.
        3914  +
/// Error type for the `MalformedBoolean` operation.
        3915  +
/// Each variant represents an error that can occur for the `MalformedBoolean` operation.
 4118   3916   
#[derive(::std::fmt::Debug)]
 4119         -
pub enum JsonIntEnumsError {
        3917  +
pub enum MalformedBooleanError {
 4120   3918   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 4121   3919   
    ValidationException(crate::error::ValidationException),
 4122   3920   
    #[allow(missing_docs)] // documentation missing in model
 4123   3921   
    InternalServerError(crate::error::InternalServerError),
 4124   3922   
}
 4125         -
impl ::std::fmt::Display for JsonIntEnumsError {
        3923  +
impl ::std::fmt::Display for MalformedBooleanError {
 4126   3924   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4127   3925   
        match &self {
 4128         -
            JsonIntEnumsError::ValidationException(_inner) => _inner.fmt(f),
 4129         -
            JsonIntEnumsError::InternalServerError(_inner) => _inner.fmt(f),
        3926  +
            MalformedBooleanError::ValidationException(_inner) => _inner.fmt(f),
        3927  +
            MalformedBooleanError::InternalServerError(_inner) => _inner.fmt(f),
 4130   3928   
        }
 4131   3929   
    }
 4132   3930   
}
 4133         -
impl JsonIntEnumsError {
 4134         -
    /// Returns `true` if the error kind is `JsonIntEnumsError::ValidationException`.
        3931  +
impl MalformedBooleanError {
        3932  +
    /// Returns `true` if the error kind is `MalformedBooleanError::ValidationException`.
 4135   3933   
    pub fn is_validation_exception(&self) -> bool {
 4136         -
        matches!(&self, JsonIntEnumsError::ValidationException(_))
        3934  +
        matches!(&self, MalformedBooleanError::ValidationException(_))
 4137   3935   
    }
 4138         -
    /// Returns `true` if the error kind is `JsonIntEnumsError::InternalServerError`.
        3936  +
    /// Returns `true` if the error kind is `MalformedBooleanError::InternalServerError`.
 4139   3937   
    pub fn is_internal_server_error(&self) -> bool {
 4140         -
        matches!(&self, JsonIntEnumsError::InternalServerError(_))
        3938  +
        matches!(&self, MalformedBooleanError::InternalServerError(_))
 4141   3939   
    }
 4142   3940   
    /// Returns the error name string by matching the correct variant.
 4143   3941   
    pub fn name(&self) -> &'static str {
 4144   3942   
        match &self {
 4145         -
            JsonIntEnumsError::ValidationException(_inner) => _inner.name(),
 4146         -
            JsonIntEnumsError::InternalServerError(_inner) => _inner.name(),
        3943  +
            MalformedBooleanError::ValidationException(_inner) => _inner.name(),
        3944  +
            MalformedBooleanError::InternalServerError(_inner) => _inner.name(),
 4147   3945   
        }
 4148   3946   
    }
 4149   3947   
}
 4150         -
impl ::std::error::Error for JsonIntEnumsError {
        3948  +
impl ::std::error::Error for MalformedBooleanError {
 4151   3949   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4152   3950   
        match &self {
 4153         -
            JsonIntEnumsError::ValidationException(_inner) => Some(_inner),
 4154         -
            JsonIntEnumsError::InternalServerError(_inner) => Some(_inner),
        3951  +
            MalformedBooleanError::ValidationException(_inner) => Some(_inner),
        3952  +
            MalformedBooleanError::InternalServerError(_inner) => Some(_inner),
 4155   3953   
        }
 4156   3954   
    }
 4157   3955   
}
 4158         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonIntEnumsError {
 4159         -
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonIntEnumsError {
        3956  +
impl ::std::convert::From<crate::error::ValidationException>
        3957  +
    for crate::error::MalformedBooleanError
        3958  +
{
        3959  +
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedBooleanError {
 4160   3960   
        Self::ValidationException(variant)
 4161   3961   
    }
 4162   3962   
}
 4163         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonIntEnumsError {
 4164         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonIntEnumsError {
        3963  +
impl ::std::convert::From<crate::error::InternalServerError>
        3964  +
    for crate::error::MalformedBooleanError
        3965  +
{
        3966  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedBooleanError {
 4165   3967   
        Self::InternalServerError(variant)
 4166   3968   
    }
 4167   3969   
}
 4168   3970   
 4169         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonIntEnumsError {
 4170         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonIntEnumsError {
        3971  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedBooleanError {
        3972  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedBooleanError {
 4171   3973   
        ::pyo3::Python::with_gil(|py| {
 4172   3974   
            let error = variant.value(py);
 4173   3975   
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 4174   3976   
                return error.into();
 4175   3977   
            }
 4176   3978   
            crate::error::InternalServerError {
 4177   3979   
                message: error.to_string(),
 4178   3980   
            }
 4179   3981   
            .into()
 4180   3982   
        })
 4181   3983   
    }
 4182   3984   
}
 4183   3985   
 4184         -
/// Error type for the `JsonEnums` operation.
 4185         -
/// Each variant represents an error that can occur for the `JsonEnums` operation.
        3986  +
/// Error type for the `MalformedList` operation.
        3987  +
/// Each variant represents an error that can occur for the `MalformedList` operation.
 4186   3988   
#[derive(::std::fmt::Debug)]
 4187         -
pub enum JsonEnumsError {
 4188         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 4189         -
    ValidationException(crate::error::ValidationException),
        3989  +
pub enum MalformedListError {
 4190   3990   
    #[allow(missing_docs)] // documentation missing in model
 4191   3991   
    InternalServerError(crate::error::InternalServerError),
 4192   3992   
}
 4193         -
impl ::std::fmt::Display for JsonEnumsError {
        3993  +
impl ::std::fmt::Display for MalformedListError {
 4194   3994   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4195   3995   
        match &self {
 4196         -
            JsonEnumsError::ValidationException(_inner) => _inner.fmt(f),
 4197         -
            JsonEnumsError::InternalServerError(_inner) => _inner.fmt(f),
        3996  +
            MalformedListError::InternalServerError(_inner) => _inner.fmt(f),
 4198   3997   
        }
 4199   3998   
    }
 4200   3999   
}
 4201         -
impl JsonEnumsError {
 4202         -
    /// Returns `true` if the error kind is `JsonEnumsError::ValidationException`.
 4203         -
    pub fn is_validation_exception(&self) -> bool {
 4204         -
        matches!(&self, JsonEnumsError::ValidationException(_))
 4205         -
    }
 4206         -
    /// Returns `true` if the error kind is `JsonEnumsError::InternalServerError`.
        4000  +
impl MalformedListError {
        4001  +
    /// Returns `true` if the error kind is `MalformedListError::InternalServerError`.
 4207   4002   
    pub fn is_internal_server_error(&self) -> bool {
 4208         -
        matches!(&self, JsonEnumsError::InternalServerError(_))
        4003  +
        matches!(&self, MalformedListError::InternalServerError(_))
 4209   4004   
    }
 4210   4005   
    /// Returns the error name string by matching the correct variant.
 4211   4006   
    pub fn name(&self) -> &'static str {
 4212   4007   
        match &self {
 4213         -
            JsonEnumsError::ValidationException(_inner) => _inner.name(),
 4214         -
            JsonEnumsError::InternalServerError(_inner) => _inner.name(),
        4008  +
            MalformedListError::InternalServerError(_inner) => _inner.name(),
 4215   4009   
        }
 4216   4010   
    }
 4217   4011   
}
 4218         -
impl ::std::error::Error for JsonEnumsError {
        4012  +
impl ::std::error::Error for MalformedListError {
 4219   4013   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4220   4014   
        match &self {
 4221         -
            JsonEnumsError::ValidationException(_inner) => Some(_inner),
 4222         -
            JsonEnumsError::InternalServerError(_inner) => Some(_inner),
        4015  +
            MalformedListError::InternalServerError(_inner) => Some(_inner),
 4223   4016   
        }
 4224   4017   
    }
 4225   4018   
}
 4226         -
impl ::std::convert::From<crate::error::ValidationException> for crate::error::JsonEnumsError {
 4227         -
    fn from(variant: crate::error::ValidationException) -> crate::error::JsonEnumsError {
 4228         -
        Self::ValidationException(variant)
 4229         -
    }
 4230         -
}
 4231         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonEnumsError {
 4232         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonEnumsError {
        4019  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedListError {
        4020  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedListError {
 4233   4021   
        Self::InternalServerError(variant)
 4234   4022   
    }
 4235   4023   
}
 4236   4024   
 4237         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonEnumsError {
 4238         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonEnumsError {
        4025  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedListError {
        4026  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedListError {
 4239   4027   
        ::pyo3::Python::with_gil(|py| {
 4240   4028   
            let error = variant.value(py);
 4241         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 4242         -
                return error.into();
 4243         -
            }
        4029  +
 4244   4030   
            crate::error::InternalServerError {
 4245   4031   
                message: error.to_string(),
 4246   4032   
            }
 4247   4033   
            .into()
 4248   4034   
        })
 4249   4035   
    }
 4250   4036   
}
 4251   4037   
 4252         -
/// Error type for the `JsonTimestamps` operation.
 4253         -
/// Each variant represents an error that can occur for the `JsonTimestamps` operation.
        4038  +
/// Error type for the `MalformedMap` operation.
        4039  +
/// Each variant represents an error that can occur for the `MalformedMap` operation.
 4254   4040   
#[derive(::std::fmt::Debug)]
 4255         -
pub enum JsonTimestampsError {
        4041  +
pub enum MalformedMapError {
 4256   4042   
    #[allow(missing_docs)] // documentation missing in model
 4257   4043   
    InternalServerError(crate::error::InternalServerError),
 4258   4044   
}
 4259         -
impl ::std::fmt::Display for JsonTimestampsError {
        4045  +
impl ::std::fmt::Display for MalformedMapError {
 4260   4046   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4261   4047   
        match &self {
 4262         -
            JsonTimestampsError::InternalServerError(_inner) => _inner.fmt(f),
        4048  +
            MalformedMapError::InternalServerError(_inner) => _inner.fmt(f),
 4263   4049   
        }
 4264   4050   
    }
 4265   4051   
}
 4266         -
impl JsonTimestampsError {
 4267         -
    /// Returns `true` if the error kind is `JsonTimestampsError::InternalServerError`.
        4052  +
impl MalformedMapError {
        4053  +
    /// Returns `true` if the error kind is `MalformedMapError::InternalServerError`.
 4268   4054   
    pub fn is_internal_server_error(&self) -> bool {
 4269         -
        matches!(&self, JsonTimestampsError::InternalServerError(_))
        4055  +
        matches!(&self, MalformedMapError::InternalServerError(_))
 4270   4056   
    }
 4271   4057   
    /// Returns the error name string by matching the correct variant.
 4272   4058   
    pub fn name(&self) -> &'static str {
 4273   4059   
        match &self {
 4274         -
            JsonTimestampsError::InternalServerError(_inner) => _inner.name(),
        4060  +
            MalformedMapError::InternalServerError(_inner) => _inner.name(),
 4275   4061   
        }
 4276   4062   
    }
 4277   4063   
}
 4278         -
impl ::std::error::Error for JsonTimestampsError {
        4064  +
impl ::std::error::Error for MalformedMapError {
 4279   4065   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4280   4066   
        match &self {
 4281         -
            JsonTimestampsError::InternalServerError(_inner) => Some(_inner),
        4067  +
            MalformedMapError::InternalServerError(_inner) => Some(_inner),
 4282   4068   
        }
 4283   4069   
    }
 4284   4070   
}
 4285         -
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::JsonTimestampsError {
 4286         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::JsonTimestampsError {
        4071  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedMapError {
        4072  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedMapError {
 4287   4073   
        Self::InternalServerError(variant)
 4288   4074   
    }
 4289   4075   
}
 4290   4076   
 4291         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::JsonTimestampsError {
 4292         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::JsonTimestampsError {
        4077  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedMapError {
        4078  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedMapError {
 4293   4079   
        ::pyo3::Python::with_gil(|py| {
 4294   4080   
            let error = variant.value(py);
 4295   4081   
 4296   4082   
            crate::error::InternalServerError {
 4297   4083   
                message: error.to_string(),
 4298   4084   
            }
 4299   4085   
            .into()
 4300   4086   
        })
 4301   4087   
    }
 4302   4088   
}
 4303   4089   
 4304         -
/// Error type for the `SimpleScalarProperties` operation.
 4305         -
/// Each variant represents an error that can occur for the `SimpleScalarProperties` operation.
        4090  +
/// Error type for the `MalformedBlob` operation.
        4091  +
/// Each variant represents an error that can occur for the `MalformedBlob` operation.
 4306   4092   
#[derive(::std::fmt::Debug)]
 4307         -
pub enum SimpleScalarPropertiesError {
        4093  +
pub enum MalformedBlobError {
 4308   4094   
    #[allow(missing_docs)] // documentation missing in model
 4309   4095   
    InternalServerError(crate::error::InternalServerError),
 4310   4096   
}
 4311         -
impl ::std::fmt::Display for SimpleScalarPropertiesError {
        4097  +
impl ::std::fmt::Display for MalformedBlobError {
 4312   4098   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4313   4099   
        match &self {
 4314         -
            SimpleScalarPropertiesError::InternalServerError(_inner) => _inner.fmt(f),
        4100  +
            MalformedBlobError::InternalServerError(_inner) => _inner.fmt(f),
 4315   4101   
        }
 4316   4102   
    }
 4317   4103   
}
 4318         -
impl SimpleScalarPropertiesError {
 4319         -
    /// Returns `true` if the error kind is `SimpleScalarPropertiesError::InternalServerError`.
        4104  +
impl MalformedBlobError {
        4105  +
    /// Returns `true` if the error kind is `MalformedBlobError::InternalServerError`.
 4320   4106   
    pub fn is_internal_server_error(&self) -> bool {
 4321         -
        matches!(&self, SimpleScalarPropertiesError::InternalServerError(_))
        4107  +
        matches!(&self, MalformedBlobError::InternalServerError(_))
 4322   4108   
    }
 4323   4109   
    /// Returns the error name string by matching the correct variant.
 4324   4110   
    pub fn name(&self) -> &'static str {
 4325   4111   
        match &self {
 4326         -
            SimpleScalarPropertiesError::InternalServerError(_inner) => _inner.name(),
        4112  +
            MalformedBlobError::InternalServerError(_inner) => _inner.name(),
 4327   4113   
        }
 4328   4114   
    }
 4329   4115   
}
 4330         -
impl ::std::error::Error for SimpleScalarPropertiesError {
        4116  +
impl ::std::error::Error for MalformedBlobError {
 4331   4117   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4332   4118   
        match &self {
 4333         -
            SimpleScalarPropertiesError::InternalServerError(_inner) => Some(_inner),
        4119  +
            MalformedBlobError::InternalServerError(_inner) => Some(_inner),
 4334   4120   
        }
 4335   4121   
    }
 4336   4122   
}
 4337         -
impl ::std::convert::From<crate::error::InternalServerError>
 4338         -
    for crate::error::SimpleScalarPropertiesError
 4339         -
{
 4340         -
    fn from(
 4341         -
        variant: crate::error::InternalServerError,
 4342         -
    ) -> crate::error::SimpleScalarPropertiesError {
        4123  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedBlobError {
        4124  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedBlobError {
 4343   4125   
        Self::InternalServerError(variant)
 4344   4126   
    }
 4345   4127   
}
 4346   4128   
 4347         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::SimpleScalarPropertiesError {
 4348         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::SimpleScalarPropertiesError {
        4129  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedBlobError {
        4130  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedBlobError {
 4349   4131   
        ::pyo3::Python::with_gil(|py| {
 4350   4132   
            let error = variant.value(py);
 4351   4133   
 4352   4134   
            crate::error::InternalServerError {
 4353   4135   
                message: error.to_string(),
 4354   4136   
            }
 4355   4137   
            .into()
 4356   4138   
        })
 4357   4139   
    }
 4358   4140   
}
 4359   4141   
 4360         -
/// Error type for the `GreetingWithErrors` operation.
 4361         -
/// Each variant represents an error that can occur for the `GreetingWithErrors` operation.
        4142  +
/// Error type for the `MalformedByte` operation.
        4143  +
/// Each variant represents an error that can occur for the `MalformedByte` operation.
 4362   4144   
#[derive(::std::fmt::Debug)]
 4363         -
pub enum GreetingWithErrorsError {
 4364         -
    /// This error is thrown when an invalid greeting value is provided.
 4365         -
    InvalidGreeting(crate::error::InvalidGreeting),
 4366         -
    /// This error is thrown when a request is invalid.
 4367         -
    ComplexError(crate::error::ComplexError),
 4368         -
    /// This error has test cases that test some of the dark corners of Amazon service framework history. It should only be implemented by clients.
 4369         -
    FooError(crate::error::FooError),
        4145  +
pub enum MalformedByteError {
        4146  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4147  +
    ValidationException(crate::error::ValidationException),
 4370   4148   
    #[allow(missing_docs)] // documentation missing in model
 4371   4149   
    InternalServerError(crate::error::InternalServerError),
 4372   4150   
}
 4373         -
impl ::std::fmt::Display for GreetingWithErrorsError {
        4151  +
impl ::std::fmt::Display for MalformedByteError {
 4374   4152   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4375   4153   
        match &self {
 4376         -
            GreetingWithErrorsError::InvalidGreeting(_inner) => _inner.fmt(f),
 4377         -
            GreetingWithErrorsError::ComplexError(_inner) => _inner.fmt(f),
 4378         -
            GreetingWithErrorsError::FooError(_inner) => _inner.fmt(f),
 4379         -
            GreetingWithErrorsError::InternalServerError(_inner) => _inner.fmt(f),
        4154  +
            MalformedByteError::ValidationException(_inner) => _inner.fmt(f),
        4155  +
            MalformedByteError::InternalServerError(_inner) => _inner.fmt(f),
 4380   4156   
        }
 4381   4157   
    }
 4382   4158   
}
 4383         -
impl GreetingWithErrorsError {
 4384         -
    /// Returns `true` if the error kind is `GreetingWithErrorsError::InvalidGreeting`.
 4385         -
    pub fn is_invalid_greeting(&self) -> bool {
 4386         -
        matches!(&self, GreetingWithErrorsError::InvalidGreeting(_))
 4387         -
    }
 4388         -
    /// Returns `true` if the error kind is `GreetingWithErrorsError::ComplexError`.
 4389         -
    pub fn is_complex_error(&self) -> bool {
 4390         -
        matches!(&self, GreetingWithErrorsError::ComplexError(_))
 4391         -
    }
 4392         -
    /// Returns `true` if the error kind is `GreetingWithErrorsError::FooError`.
 4393         -
    pub fn is_foo_error(&self) -> bool {
 4394         -
        matches!(&self, GreetingWithErrorsError::FooError(_))
        4159  +
impl MalformedByteError {
        4160  +
    /// Returns `true` if the error kind is `MalformedByteError::ValidationException`.
        4161  +
    pub fn is_validation_exception(&self) -> bool {
        4162  +
        matches!(&self, MalformedByteError::ValidationException(_))
 4395   4163   
    }
 4396         -
    /// Returns `true` if the error kind is `GreetingWithErrorsError::InternalServerError`.
        4164  +
    /// Returns `true` if the error kind is `MalformedByteError::InternalServerError`.
 4397   4165   
    pub fn is_internal_server_error(&self) -> bool {
 4398         -
        matches!(&self, GreetingWithErrorsError::InternalServerError(_))
        4166  +
        matches!(&self, MalformedByteError::InternalServerError(_))
 4399   4167   
    }
 4400   4168   
    /// Returns the error name string by matching the correct variant.
 4401   4169   
    pub fn name(&self) -> &'static str {
 4402   4170   
        match &self {
 4403         -
            GreetingWithErrorsError::InvalidGreeting(_inner) => _inner.name(),
 4404         -
            GreetingWithErrorsError::ComplexError(_inner) => _inner.name(),
 4405         -
            GreetingWithErrorsError::FooError(_inner) => _inner.name(),
 4406         -
            GreetingWithErrorsError::InternalServerError(_inner) => _inner.name(),
        4171  +
            MalformedByteError::ValidationException(_inner) => _inner.name(),
        4172  +
            MalformedByteError::InternalServerError(_inner) => _inner.name(),
 4407   4173   
        }
 4408   4174   
    }
 4409   4175   
}
 4410         -
impl ::std::error::Error for GreetingWithErrorsError {
        4176  +
impl ::std::error::Error for MalformedByteError {
 4411   4177   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4412   4178   
        match &self {
 4413         -
            GreetingWithErrorsError::InvalidGreeting(_inner) => Some(_inner),
 4414         -
            GreetingWithErrorsError::ComplexError(_inner) => Some(_inner),
 4415         -
            GreetingWithErrorsError::FooError(_inner) => Some(_inner),
 4416         -
            GreetingWithErrorsError::InternalServerError(_inner) => Some(_inner),
        4179  +
            MalformedByteError::ValidationException(_inner) => Some(_inner),
        4180  +
            MalformedByteError::InternalServerError(_inner) => Some(_inner),
 4417   4181   
        }
 4418   4182   
    }
 4419   4183   
}
 4420         -
impl ::std::convert::From<crate::error::InvalidGreeting> for crate::error::GreetingWithErrorsError {
 4421         -
    fn from(variant: crate::error::InvalidGreeting) -> crate::error::GreetingWithErrorsError {
 4422         -
        Self::InvalidGreeting(variant)
 4423         -
    }
 4424         -
}
 4425         -
impl ::std::convert::From<crate::error::ComplexError> for crate::error::GreetingWithErrorsError {
 4426         -
    fn from(variant: crate::error::ComplexError) -> crate::error::GreetingWithErrorsError {
 4427         -
        Self::ComplexError(variant)
 4428         -
    }
 4429         -
}
 4430         -
impl ::std::convert::From<crate::error::FooError> for crate::error::GreetingWithErrorsError {
 4431         -
    fn from(variant: crate::error::FooError) -> crate::error::GreetingWithErrorsError {
 4432         -
        Self::FooError(variant)
        4184  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedByteError {
        4185  +
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedByteError {
        4186  +
        Self::ValidationException(variant)
 4433   4187   
    }
 4434   4188   
}
 4435         -
impl ::std::convert::From<crate::error::InternalServerError>
 4436         -
    for crate::error::GreetingWithErrorsError
 4437         -
{
 4438         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::GreetingWithErrorsError {
        4189  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedByteError {
        4190  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedByteError {
 4439   4191   
        Self::InternalServerError(variant)
 4440   4192   
    }
 4441   4193   
}
 4442   4194   
 4443         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::GreetingWithErrorsError {
 4444         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::GreetingWithErrorsError {
        4195  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedByteError {
        4196  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedByteError {
 4445   4197   
        ::pyo3::Python::with_gil(|py| {
 4446   4198   
            let error = variant.value(py);
 4447         -
            if let Ok(error) = error.extract::<crate::error::InvalidGreeting>() {
        4199  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 4448   4200   
                return error.into();
 4449   4201   
            }
 4450         -
            if let Ok(error) = error.extract::<crate::error::ComplexError>() {
 4451         -
                return error.into();
 4452         -
            }
 4453         -
            if let Ok(error) = error.extract::<crate::error::FooError>() {
 4454         -
                return error.into();
 4455         -
            }
 4456         -
            crate::error::InternalServerError {
 4457         -
                message: error.to_string(),
        4202  +
            crate::error::InternalServerError {
        4203  +
                message: error.to_string(),
 4458   4204   
            }
 4459   4205   
            .into()
 4460   4206   
        })
 4461   4207   
    }
 4462   4208   
}
 4463   4209   
 4464         -
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 4465         -
/// :rtype None:
 4466         -
/// This error has test cases that test some of the dark corners of Amazon service framework history. It should only be implemented by clients.
 4467         -
#[derive(
 4468         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 4469         -
)]
 4470         -
pub struct FooError {}
 4471         -
#[allow(clippy::new_without_default)]
 4472         -
#[allow(clippy::too_many_arguments)]
 4473         -
#[::pyo3::pymethods]
 4474         -
impl FooError {
 4475         -
    #[new]
 4476         -
    pub fn new() -> Self {
 4477         -
        Self {}
 4478         -
    }
 4479         -
    fn __repr__(&self) -> String {
 4480         -
        format!("{self:?}")
 4481         -
    }
 4482         -
    fn __str__(&self) -> String {
 4483         -
        format!("{self:?}")
 4484         -
    }
 4485         -
}
 4486         -
impl FooError {
 4487         -
    #[doc(hidden)]
 4488         -
    /// Returns the error name.
 4489         -
    pub fn name(&self) -> &'static str {
 4490         -
        "FooError"
 4491         -
    }
 4492         -
}
 4493         -
impl ::std::fmt::Display for FooError {
 4494         -
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4495         -
        ::std::write!(f, "FooError")?;
 4496         -
        Ok(())
 4497         -
    }
 4498         -
}
 4499         -
impl ::std::error::Error for FooError {}
 4500         -
impl FooError {
 4501         -
    /// Creates a new builder-style object to manufacture [`FooError`](crate::error::FooError).
 4502         -
    pub fn builder() -> crate::error::foo_error::Builder {
 4503         -
        crate::error::foo_error::Builder::default()
 4504         -
    }
 4505         -
}
 4506         -
 4507         -
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 4508         -
/// :param header typing.Optional\[str\]:
 4509         -
/// :param top_level typing.Optional\[str\]:
 4510         -
/// :param nested typing.Optional\[rest_json.model.ComplexNestedErrorData\]:
 4511         -
/// :rtype None:
 4512         -
/// This error is thrown when a request is invalid.
 4513         -
#[derive(
 4514         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 4515         -
)]
 4516         -
pub struct ComplexError {
 4517         -
    #[pyo3(get, set)]
 4518         -
    /// :type typing.Optional\[str\]:
 4519         -
    #[allow(missing_docs)] // documentation missing in model
 4520         -
    pub header: ::std::option::Option<::std::string::String>,
 4521         -
    #[pyo3(get, set)]
 4522         -
    /// :type typing.Optional\[str\]:
 4523         -
    #[allow(missing_docs)] // documentation missing in model
 4524         -
    pub top_level: ::std::option::Option<::std::string::String>,
 4525         -
    #[pyo3(get, set)]
 4526         -
    /// :type typing.Optional\[rest_json.model.ComplexNestedErrorData\]:
 4527         -
    #[allow(missing_docs)] // documentation missing in model
 4528         -
    pub nested: ::std::option::Option<crate::model::ComplexNestedErrorData>,
 4529         -
}
 4530         -
impl ComplexError {
 4531         -
    #[allow(missing_docs)] // documentation missing in model
 4532         -
    pub fn header(&self) -> ::std::option::Option<&str> {
 4533         -
        self.header.as_deref()
 4534         -
    }
 4535         -
    #[allow(missing_docs)] // documentation missing in model
 4536         -
    pub fn top_level(&self) -> ::std::option::Option<&str> {
 4537         -
        self.top_level.as_deref()
 4538         -
    }
 4539         -
    #[allow(missing_docs)] // documentation missing in model
 4540         -
    pub fn nested(&self) -> ::std::option::Option<&crate::model::ComplexNestedErrorData> {
 4541         -
        self.nested.as_ref()
 4542         -
    }
 4543         -
}
 4544         -
#[allow(clippy::new_without_default)]
 4545         -
#[allow(clippy::too_many_arguments)]
 4546         -
#[::pyo3::pymethods]
 4547         -
impl ComplexError {
 4548         -
    #[new]
 4549         -
    pub fn new(
 4550         -
        header: ::std::option::Option<::std::string::String>,
 4551         -
        top_level: ::std::option::Option<::std::string::String>,
 4552         -
        nested: ::std::option::Option<crate::model::ComplexNestedErrorData>,
 4553         -
    ) -> Self {
 4554         -
        Self {
 4555         -
            header,
 4556         -
            top_level,
 4557         -
            nested,
 4558         -
        }
 4559         -
    }
 4560         -
    fn __repr__(&self) -> String {
 4561         -
        format!("{self:?}")
 4562         -
    }
 4563         -
    fn __str__(&self) -> String {
 4564         -
        format!("{self:?}")
 4565         -
    }
 4566         -
}
 4567         -
impl ComplexError {
 4568         -
    #[doc(hidden)]
 4569         -
    /// Returns the error name.
 4570         -
    pub fn name(&self) -> &'static str {
 4571         -
        "ComplexError"
 4572         -
    }
 4573         -
}
 4574         -
impl ::std::fmt::Display for ComplexError {
 4575         -
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4576         -
        ::std::write!(f, "ComplexError")?;
 4577         -
        Ok(())
 4578         -
    }
 4579         -
}
 4580         -
impl ::std::error::Error for ComplexError {}
 4581         -
impl ComplexError {
 4582         -
    /// Creates a new builder-style object to manufacture [`ComplexError`](crate::error::ComplexError).
 4583         -
    pub fn builder() -> crate::error::complex_error::Builder {
 4584         -
        crate::error::complex_error::Builder::default()
 4585         -
    }
 4586         -
}
 4587         -
 4588         -
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 4589         -
/// :param message typing.Optional\[str\]:
 4590         -
/// :rtype None:
 4591         -
/// This error is thrown when an invalid greeting value is provided.
 4592         -
#[derive(
 4593         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 4594         -
)]
 4595         -
pub struct InvalidGreeting {
 4596         -
    #[pyo3(get, set)]
 4597         -
    /// :type typing.Optional\[str\]:
 4598         -
    #[allow(missing_docs)] // documentation missing in model
 4599         -
    pub message: ::std::option::Option<::std::string::String>,
 4600         -
}
 4601         -
#[allow(clippy::new_without_default)]
 4602         -
#[allow(clippy::too_many_arguments)]
 4603         -
#[::pyo3::pymethods]
 4604         -
impl InvalidGreeting {
 4605         -
    #[new]
 4606         -
    pub fn new(message: ::std::option::Option<::std::string::String>) -> Self {
 4607         -
        Self { message }
 4608         -
    }
 4609         -
    fn __repr__(&self) -> String {
 4610         -
        format!("{self:?}")
 4611         -
    }
 4612         -
    fn __str__(&self) -> String {
 4613         -
        format!("{self:?}")
 4614         -
    }
 4615         -
}
 4616         -
impl InvalidGreeting {
 4617         -
    /// Returns the error message.
 4618         -
    pub fn message(&self) -> ::std::option::Option<&str> {
 4619         -
        self.message.as_deref()
 4620         -
    }
 4621         -
    #[doc(hidden)]
 4622         -
    /// Returns the error name.
 4623         -
    pub fn name(&self) -> &'static str {
 4624         -
        "InvalidGreeting"
 4625         -
    }
 4626         -
}
 4627         -
impl ::std::fmt::Display for InvalidGreeting {
 4628         -
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4629         -
        ::std::write!(f, "InvalidGreeting")?;
 4630         -
        if let ::std::option::Option::Some(inner_1) = &self.message {
 4631         -
            {
 4632         -
                ::std::write!(f, ": {inner_1}")?;
 4633         -
            }
 4634         -
        }
 4635         -
        Ok(())
 4636         -
    }
 4637         -
}
 4638         -
impl ::std::error::Error for InvalidGreeting {}
 4639         -
impl InvalidGreeting {
 4640         -
    /// Creates a new builder-style object to manufacture [`InvalidGreeting`](crate::error::InvalidGreeting).
 4641         -
    pub fn builder() -> crate::error::invalid_greeting::Builder {
 4642         -
        crate::error::invalid_greeting::Builder::default()
 4643         -
    }
 4644         -
}
 4645         -
 4646         -
/// Error type for the `StreamingTraitsWithMediaType` operation.
 4647         -
/// Each variant represents an error that can occur for the `StreamingTraitsWithMediaType` operation.
        4210  +
/// Error type for the `MalformedShort` operation.
        4211  +
/// Each variant represents an error that can occur for the `MalformedShort` operation.
 4648   4212   
#[derive(::std::fmt::Debug)]
 4649         -
pub enum StreamingTraitsWithMediaTypeError {
        4213  +
pub enum MalformedShortError {
        4214  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4215  +
    ValidationException(crate::error::ValidationException),
 4650   4216   
    #[allow(missing_docs)] // documentation missing in model
 4651   4217   
    InternalServerError(crate::error::InternalServerError),
 4652   4218   
}
 4653         -
impl ::std::fmt::Display for StreamingTraitsWithMediaTypeError {
        4219  +
impl ::std::fmt::Display for MalformedShortError {
 4654   4220   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4655   4221   
        match &self {
 4656         -
            StreamingTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.fmt(f),
        4222  +
            MalformedShortError::ValidationException(_inner) => _inner.fmt(f),
        4223  +
            MalformedShortError::InternalServerError(_inner) => _inner.fmt(f),
 4657   4224   
        }
 4658   4225   
    }
 4659   4226   
}
 4660         -
impl StreamingTraitsWithMediaTypeError {
 4661         -
    /// Returns `true` if the error kind is `StreamingTraitsWithMediaTypeError::InternalServerError`.
        4227  +
impl MalformedShortError {
        4228  +
    /// Returns `true` if the error kind is `MalformedShortError::ValidationException`.
        4229  +
    pub fn is_validation_exception(&self) -> bool {
        4230  +
        matches!(&self, MalformedShortError::ValidationException(_))
        4231  +
    }
        4232  +
    /// Returns `true` if the error kind is `MalformedShortError::InternalServerError`.
 4662   4233   
    pub fn is_internal_server_error(&self) -> bool {
 4663         -
        matches!(
 4664         -
            &self,
 4665         -
            StreamingTraitsWithMediaTypeError::InternalServerError(_)
 4666         -
        )
        4234  +
        matches!(&self, MalformedShortError::InternalServerError(_))
 4667   4235   
    }
 4668   4236   
    /// Returns the error name string by matching the correct variant.
 4669   4237   
    pub fn name(&self) -> &'static str {
 4670   4238   
        match &self {
 4671         -
            StreamingTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.name(),
        4239  +
            MalformedShortError::ValidationException(_inner) => _inner.name(),
        4240  +
            MalformedShortError::InternalServerError(_inner) => _inner.name(),
 4672   4241   
        }
 4673   4242   
    }
 4674   4243   
}
 4675         -
impl ::std::error::Error for StreamingTraitsWithMediaTypeError {
        4244  +
impl ::std::error::Error for MalformedShortError {
 4676   4245   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4677   4246   
        match &self {
 4678         -
            StreamingTraitsWithMediaTypeError::InternalServerError(_inner) => Some(_inner),
        4247  +
            MalformedShortError::ValidationException(_inner) => Some(_inner),
        4248  +
            MalformedShortError::InternalServerError(_inner) => Some(_inner),
 4679   4249   
        }
 4680   4250   
    }
 4681   4251   
}
 4682         -
impl ::std::convert::From<crate::error::InternalServerError>
 4683         -
    for crate::error::StreamingTraitsWithMediaTypeError
 4684         -
{
 4685         -
    fn from(
 4686         -
        variant: crate::error::InternalServerError,
 4687         -
    ) -> crate::error::StreamingTraitsWithMediaTypeError {
        4252  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedShortError {
        4253  +
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedShortError {
        4254  +
        Self::ValidationException(variant)
        4255  +
    }
        4256  +
}
        4257  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedShortError {
        4258  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedShortError {
 4688   4259   
        Self::InternalServerError(variant)
 4689   4260   
    }
 4690   4261   
}
 4691   4262   
 4692         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::StreamingTraitsWithMediaTypeError {
 4693         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::StreamingTraitsWithMediaTypeError {
        4263  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedShortError {
        4264  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedShortError {
 4694   4265   
        ::pyo3::Python::with_gil(|py| {
 4695   4266   
            let error = variant.value(py);
 4696         -
        4267  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4268  +
                return error.into();
        4269  +
            }
 4697   4270   
            crate::error::InternalServerError {
 4698   4271   
                message: error.to_string(),
 4699   4272   
            }
 4700   4273   
            .into()
 4701   4274   
        })
 4702   4275   
    }
 4703   4276   
}
 4704   4277   
 4705         -
/// Error type for the `StreamingTraitsRequireLength` operation.
 4706         -
/// Each variant represents an error that can occur for the `StreamingTraitsRequireLength` operation.
        4278  +
/// Error type for the `MalformedLong` operation.
        4279  +
/// Each variant represents an error that can occur for the `MalformedLong` operation.
 4707   4280   
#[derive(::std::fmt::Debug)]
 4708         -
pub enum StreamingTraitsRequireLengthError {
        4281  +
pub enum MalformedLongError {
        4282  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4283  +
    ValidationException(crate::error::ValidationException),
 4709   4284   
    #[allow(missing_docs)] // documentation missing in model
 4710   4285   
    InternalServerError(crate::error::InternalServerError),
 4711   4286   
}
 4712         -
impl ::std::fmt::Display for StreamingTraitsRequireLengthError {
        4287  +
impl ::std::fmt::Display for MalformedLongError {
 4713   4288   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4714   4289   
        match &self {
 4715         -
            StreamingTraitsRequireLengthError::InternalServerError(_inner) => _inner.fmt(f),
        4290  +
            MalformedLongError::ValidationException(_inner) => _inner.fmt(f),
        4291  +
            MalformedLongError::InternalServerError(_inner) => _inner.fmt(f),
 4716   4292   
        }
 4717   4293   
    }
 4718   4294   
}
 4719         -
impl StreamingTraitsRequireLengthError {
 4720         -
    /// Returns `true` if the error kind is `StreamingTraitsRequireLengthError::InternalServerError`.
        4295  +
impl MalformedLongError {
        4296  +
    /// Returns `true` if the error kind is `MalformedLongError::ValidationException`.
        4297  +
    pub fn is_validation_exception(&self) -> bool {
        4298  +
        matches!(&self, MalformedLongError::ValidationException(_))
        4299  +
    }
        4300  +
    /// Returns `true` if the error kind is `MalformedLongError::InternalServerError`.
 4721   4301   
    pub fn is_internal_server_error(&self) -> bool {
 4722         -
        matches!(
 4723         -
            &self,
 4724         -
            StreamingTraitsRequireLengthError::InternalServerError(_)
 4725         -
        )
        4302  +
        matches!(&self, MalformedLongError::InternalServerError(_))
 4726   4303   
    }
 4727   4304   
    /// Returns the error name string by matching the correct variant.
 4728   4305   
    pub fn name(&self) -> &'static str {
 4729   4306   
        match &self {
 4730         -
            StreamingTraitsRequireLengthError::InternalServerError(_inner) => _inner.name(),
        4307  +
            MalformedLongError::ValidationException(_inner) => _inner.name(),
        4308  +
            MalformedLongError::InternalServerError(_inner) => _inner.name(),
 4731   4309   
        }
 4732   4310   
    }
 4733   4311   
}
 4734         -
impl ::std::error::Error for StreamingTraitsRequireLengthError {
        4312  +
impl ::std::error::Error for MalformedLongError {
 4735   4313   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4736   4314   
        match &self {
 4737         -
            StreamingTraitsRequireLengthError::InternalServerError(_inner) => Some(_inner),
        4315  +
            MalformedLongError::ValidationException(_inner) => Some(_inner),
        4316  +
            MalformedLongError::InternalServerError(_inner) => Some(_inner),
 4738   4317   
        }
 4739   4318   
    }
 4740   4319   
}
 4741         -
impl ::std::convert::From<crate::error::InternalServerError>
 4742         -
    for crate::error::StreamingTraitsRequireLengthError
 4743         -
{
 4744         -
    fn from(
 4745         -
        variant: crate::error::InternalServerError,
 4746         -
    ) -> crate::error::StreamingTraitsRequireLengthError {
        4320  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedLongError {
        4321  +
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedLongError {
        4322  +
        Self::ValidationException(variant)
        4323  +
    }
        4324  +
}
        4325  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedLongError {
        4326  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedLongError {
 4747   4327   
        Self::InternalServerError(variant)
 4748   4328   
    }
 4749   4329   
}
 4750   4330   
 4751         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::StreamingTraitsRequireLengthError {
 4752         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::StreamingTraitsRequireLengthError {
        4331  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedLongError {
        4332  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedLongError {
 4753   4333   
        ::pyo3::Python::with_gil(|py| {
 4754   4334   
            let error = variant.value(py);
 4755         -
        4335  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4336  +
                return error.into();
        4337  +
            }
 4756   4338   
            crate::error::InternalServerError {
 4757   4339   
                message: error.to_string(),
 4758   4340   
            }
 4759   4341   
            .into()
 4760   4342   
        })
 4761   4343   
    }
 4762   4344   
}
 4763   4345   
 4764         -
/// Error type for the `StreamingTraits` operation.
 4765         -
/// Each variant represents an error that can occur for the `StreamingTraits` operation.
        4346  +
/// Error type for the `MalformedFloat` operation.
        4347  +
/// Each variant represents an error that can occur for the `MalformedFloat` operation.
 4766   4348   
#[derive(::std::fmt::Debug)]
 4767         -
pub enum StreamingTraitsError {
        4349  +
pub enum MalformedFloatError {
        4350  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4351  +
    ValidationException(crate::error::ValidationException),
 4768   4352   
    #[allow(missing_docs)] // documentation missing in model
 4769   4353   
    InternalServerError(crate::error::InternalServerError),
 4770   4354   
}
 4771         -
impl ::std::fmt::Display for StreamingTraitsError {
        4355  +
impl ::std::fmt::Display for MalformedFloatError {
 4772   4356   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4773   4357   
        match &self {
 4774         -
            StreamingTraitsError::InternalServerError(_inner) => _inner.fmt(f),
        4358  +
            MalformedFloatError::ValidationException(_inner) => _inner.fmt(f),
        4359  +
            MalformedFloatError::InternalServerError(_inner) => _inner.fmt(f),
 4775   4360   
        }
 4776   4361   
    }
 4777   4362   
}
 4778         -
impl StreamingTraitsError {
 4779         -
    /// Returns `true` if the error kind is `StreamingTraitsError::InternalServerError`.
        4363  +
impl MalformedFloatError {
        4364  +
    /// Returns `true` if the error kind is `MalformedFloatError::ValidationException`.
        4365  +
    pub fn is_validation_exception(&self) -> bool {
        4366  +
        matches!(&self, MalformedFloatError::ValidationException(_))
        4367  +
    }
        4368  +
    /// Returns `true` if the error kind is `MalformedFloatError::InternalServerError`.
 4780   4369   
    pub fn is_internal_server_error(&self) -> bool {
 4781         -
        matches!(&self, StreamingTraitsError::InternalServerError(_))
        4370  +
        matches!(&self, MalformedFloatError::InternalServerError(_))
 4782   4371   
    }
 4783   4372   
    /// Returns the error name string by matching the correct variant.
 4784   4373   
    pub fn name(&self) -> &'static str {
 4785   4374   
        match &self {
 4786         -
            StreamingTraitsError::InternalServerError(_inner) => _inner.name(),
        4375  +
            MalformedFloatError::ValidationException(_inner) => _inner.name(),
        4376  +
            MalformedFloatError::InternalServerError(_inner) => _inner.name(),
 4787   4377   
        }
 4788   4378   
    }
 4789   4379   
}
 4790         -
impl ::std::error::Error for StreamingTraitsError {
        4380  +
impl ::std::error::Error for MalformedFloatError {
 4791   4381   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4792   4382   
        match &self {
 4793         -
            StreamingTraitsError::InternalServerError(_inner) => Some(_inner),
        4383  +
            MalformedFloatError::ValidationException(_inner) => Some(_inner),
        4384  +
            MalformedFloatError::InternalServerError(_inner) => Some(_inner),
 4794   4385   
        }
 4795   4386   
    }
 4796   4387   
}
 4797         -
impl ::std::convert::From<crate::error::InternalServerError>
 4798         -
    for crate::error::StreamingTraitsError
 4799         -
{
 4800         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::StreamingTraitsError {
        4388  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::MalformedFloatError {
        4389  +
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedFloatError {
        4390  +
        Self::ValidationException(variant)
        4391  +
    }
        4392  +
}
        4393  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::MalformedFloatError {
        4394  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedFloatError {
 4801   4395   
        Self::InternalServerError(variant)
 4802   4396   
    }
 4803   4397   
}
 4804   4398   
 4805         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::StreamingTraitsError {
 4806         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::StreamingTraitsError {
        4399  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedFloatError {
        4400  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedFloatError {
 4807   4401   
        ::pyo3::Python::with_gil(|py| {
 4808   4402   
            let error = variant.value(py);
 4809         -
        4403  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4404  +
                return error.into();
        4405  +
            }
 4810   4406   
            crate::error::InternalServerError {
 4811   4407   
                message: error.to_string(),
 4812   4408   
            }
 4813   4409   
            .into()
 4814   4410   
        })
 4815   4411   
    }
 4816   4412   
}
 4817   4413   
 4818         -
/// Error type for the `ResponseCodeHttpFallback` operation.
 4819         -
/// Each variant represents an error that can occur for the `ResponseCodeHttpFallback` operation.
        4414  +
/// Error type for the `MalformedDouble` operation.
        4415  +
/// Each variant represents an error that can occur for the `MalformedDouble` operation.
 4820   4416   
#[derive(::std::fmt::Debug)]
 4821         -
pub enum ResponseCodeHttpFallbackError {
        4417  +
pub enum MalformedDoubleError {
        4418  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4419  +
    ValidationException(crate::error::ValidationException),
 4822   4420   
    #[allow(missing_docs)] // documentation missing in model
 4823   4421   
    InternalServerError(crate::error::InternalServerError),
 4824   4422   
}
 4825         -
impl ::std::fmt::Display for ResponseCodeHttpFallbackError {
        4423  +
impl ::std::fmt::Display for MalformedDoubleError {
 4826   4424   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4827   4425   
        match &self {
 4828         -
            ResponseCodeHttpFallbackError::InternalServerError(_inner) => _inner.fmt(f),
        4426  +
            MalformedDoubleError::ValidationException(_inner) => _inner.fmt(f),
        4427  +
            MalformedDoubleError::InternalServerError(_inner) => _inner.fmt(f),
 4829   4428   
        }
 4830   4429   
    }
 4831   4430   
}
 4832         -
impl ResponseCodeHttpFallbackError {
 4833         -
    /// Returns `true` if the error kind is `ResponseCodeHttpFallbackError::InternalServerError`.
        4431  +
impl MalformedDoubleError {
        4432  +
    /// Returns `true` if the error kind is `MalformedDoubleError::ValidationException`.
        4433  +
    pub fn is_validation_exception(&self) -> bool {
        4434  +
        matches!(&self, MalformedDoubleError::ValidationException(_))
        4435  +
    }
        4436  +
    /// Returns `true` if the error kind is `MalformedDoubleError::InternalServerError`.
 4834   4437   
    pub fn is_internal_server_error(&self) -> bool {
 4835         -
        matches!(&self, ResponseCodeHttpFallbackError::InternalServerError(_))
        4438  +
        matches!(&self, MalformedDoubleError::InternalServerError(_))
 4836   4439   
    }
 4837   4440   
    /// Returns the error name string by matching the correct variant.
 4838   4441   
    pub fn name(&self) -> &'static str {
 4839   4442   
        match &self {
 4840         -
            ResponseCodeHttpFallbackError::InternalServerError(_inner) => _inner.name(),
        4443  +
            MalformedDoubleError::ValidationException(_inner) => _inner.name(),
        4444  +
            MalformedDoubleError::InternalServerError(_inner) => _inner.name(),
 4841   4445   
        }
 4842   4446   
    }
 4843   4447   
}
 4844         -
impl ::std::error::Error for ResponseCodeHttpFallbackError {
        4448  +
impl ::std::error::Error for MalformedDoubleError {
 4845   4449   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4846   4450   
        match &self {
 4847         -
            ResponseCodeHttpFallbackError::InternalServerError(_inner) => Some(_inner),
        4451  +
            MalformedDoubleError::ValidationException(_inner) => Some(_inner),
        4452  +
            MalformedDoubleError::InternalServerError(_inner) => Some(_inner),
 4848   4453   
        }
 4849   4454   
    }
 4850   4455   
}
        4456  +
impl ::std::convert::From<crate::error::ValidationException>
        4457  +
    for crate::error::MalformedDoubleError
        4458  +
{
        4459  +
    fn from(variant: crate::error::ValidationException) -> crate::error::MalformedDoubleError {
        4460  +
        Self::ValidationException(variant)
        4461  +
    }
        4462  +
}
 4851   4463   
impl ::std::convert::From<crate::error::InternalServerError>
 4852         -
    for crate::error::ResponseCodeHttpFallbackError
        4464  +
    for crate::error::MalformedDoubleError
 4853   4465   
{
 4854         -
    fn from(
 4855         -
        variant: crate::error::InternalServerError,
 4856         -
    ) -> crate::error::ResponseCodeHttpFallbackError {
        4466  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedDoubleError {
 4857   4467   
        Self::InternalServerError(variant)
 4858   4468   
    }
 4859   4469   
}
 4860   4470   
 4861         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeHttpFallbackError {
 4862         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeHttpFallbackError {
        4471  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedDoubleError {
        4472  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedDoubleError {
 4863   4473   
        ::pyo3::Python::with_gil(|py| {
 4864   4474   
            let error = variant.value(py);
 4865         -
        4475  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4476  +
                return error.into();
        4477  +
            }
 4866   4478   
            crate::error::InternalServerError {
 4867   4479   
                message: error.to_string(),
 4868   4480   
            }
 4869   4481   
            .into()
 4870   4482   
        })
 4871   4483   
    }
 4872   4484   
}
 4873   4485   
 4874         -
/// Error type for the `ResponseCodeRequired` operation.
 4875         -
/// Each variant represents an error that can occur for the `ResponseCodeRequired` operation.
        4486  +
/// Error type for the `MalformedString` operation.
        4487  +
/// Each variant represents an error that can occur for the `MalformedString` operation.
 4876   4488   
#[derive(::std::fmt::Debug)]
 4877         -
pub enum ResponseCodeRequiredError {
        4489  +
pub enum MalformedStringError {
 4878   4490   
    #[allow(missing_docs)] // documentation missing in model
 4879   4491   
    InternalServerError(crate::error::InternalServerError),
 4880   4492   
}
 4881         -
impl ::std::fmt::Display for ResponseCodeRequiredError {
        4493  +
impl ::std::fmt::Display for MalformedStringError {
 4882   4494   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4883   4495   
        match &self {
 4884         -
            ResponseCodeRequiredError::InternalServerError(_inner) => _inner.fmt(f),
        4496  +
            MalformedStringError::InternalServerError(_inner) => _inner.fmt(f),
 4885   4497   
        }
 4886   4498   
    }
 4887   4499   
}
 4888         -
impl ResponseCodeRequiredError {
 4889         -
    /// Returns `true` if the error kind is `ResponseCodeRequiredError::InternalServerError`.
        4500  +
impl MalformedStringError {
        4501  +
    /// Returns `true` if the error kind is `MalformedStringError::InternalServerError`.
 4890   4502   
    pub fn is_internal_server_error(&self) -> bool {
 4891         -
        matches!(&self, ResponseCodeRequiredError::InternalServerError(_))
        4503  +
        matches!(&self, MalformedStringError::InternalServerError(_))
 4892   4504   
    }
 4893   4505   
    /// Returns the error name string by matching the correct variant.
 4894   4506   
    pub fn name(&self) -> &'static str {
 4895   4507   
        match &self {
 4896         -
            ResponseCodeRequiredError::InternalServerError(_inner) => _inner.name(),
        4508  +
            MalformedStringError::InternalServerError(_inner) => _inner.name(),
 4897   4509   
        }
 4898   4510   
    }
 4899   4511   
}
 4900         -
impl ::std::error::Error for ResponseCodeRequiredError {
        4512  +
impl ::std::error::Error for MalformedStringError {
 4901   4513   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4902   4514   
        match &self {
 4903         -
            ResponseCodeRequiredError::InternalServerError(_inner) => Some(_inner),
        4515  +
            MalformedStringError::InternalServerError(_inner) => Some(_inner),
 4904   4516   
        }
 4905   4517   
    }
 4906   4518   
}
 4907   4519   
impl ::std::convert::From<crate::error::InternalServerError>
 4908         -
    for crate::error::ResponseCodeRequiredError
        4520  +
    for crate::error::MalformedStringError
 4909   4521   
{
 4910         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::ResponseCodeRequiredError {
        4522  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::MalformedStringError {
 4911   4523   
        Self::InternalServerError(variant)
 4912   4524   
    }
 4913   4525   
}
 4914   4526   
 4915         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeRequiredError {
 4916         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeRequiredError {
        4527  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedStringError {
        4528  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedStringError {
 4917   4529   
        ::pyo3::Python::with_gil(|py| {
 4918   4530   
            let error = variant.value(py);
 4919   4531   
 4920   4532   
            crate::error::InternalServerError {
 4921   4533   
                message: error.to_string(),
 4922   4534   
            }
 4923   4535   
            .into()
 4924   4536   
        })
 4925   4537   
    }
 4926   4538   
}
 4927   4539   
 4928         -
/// Error type for the `HttpResponseCode` operation.
 4929         -
/// Each variant represents an error that can occur for the `HttpResponseCode` operation.
        4540  +
/// Error type for the `MalformedTimestampPathDefault` operation.
        4541  +
/// Each variant represents an error that can occur for the `MalformedTimestampPathDefault` operation.
 4930   4542   
#[derive(::std::fmt::Debug)]
 4931         -
pub enum HttpResponseCodeError {
        4543  +
pub enum MalformedTimestampPathDefaultError {
        4544  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4545  +
    ValidationException(crate::error::ValidationException),
 4932   4546   
    #[allow(missing_docs)] // documentation missing in model
 4933   4547   
    InternalServerError(crate::error::InternalServerError),
 4934   4548   
}
 4935         -
impl ::std::fmt::Display for HttpResponseCodeError {
        4549  +
impl ::std::fmt::Display for MalformedTimestampPathDefaultError {
 4936   4550   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4937   4551   
        match &self {
 4938         -
            HttpResponseCodeError::InternalServerError(_inner) => _inner.fmt(f),
        4552  +
            MalformedTimestampPathDefaultError::ValidationException(_inner) => _inner.fmt(f),
        4553  +
            MalformedTimestampPathDefaultError::InternalServerError(_inner) => _inner.fmt(f),
 4939   4554   
        }
 4940   4555   
    }
 4941   4556   
}
 4942         -
impl HttpResponseCodeError {
 4943         -
    /// Returns `true` if the error kind is `HttpResponseCodeError::InternalServerError`.
        4557  +
impl MalformedTimestampPathDefaultError {
        4558  +
    /// Returns `true` if the error kind is `MalformedTimestampPathDefaultError::ValidationException`.
        4559  +
    pub fn is_validation_exception(&self) -> bool {
        4560  +
        matches!(
        4561  +
            &self,
        4562  +
            MalformedTimestampPathDefaultError::ValidationException(_)
        4563  +
        )
        4564  +
    }
        4565  +
    /// Returns `true` if the error kind is `MalformedTimestampPathDefaultError::InternalServerError`.
 4944   4566   
    pub fn is_internal_server_error(&self) -> bool {
 4945         -
        matches!(&self, HttpResponseCodeError::InternalServerError(_))
        4567  +
        matches!(
        4568  +
            &self,
        4569  +
            MalformedTimestampPathDefaultError::InternalServerError(_)
        4570  +
        )
 4946   4571   
    }
 4947   4572   
    /// Returns the error name string by matching the correct variant.
 4948   4573   
    pub fn name(&self) -> &'static str {
 4949   4574   
        match &self {
 4950         -
            HttpResponseCodeError::InternalServerError(_inner) => _inner.name(),
        4575  +
            MalformedTimestampPathDefaultError::ValidationException(_inner) => _inner.name(),
        4576  +
            MalformedTimestampPathDefaultError::InternalServerError(_inner) => _inner.name(),
 4951   4577   
        }
 4952   4578   
    }
 4953   4579   
}
 4954         -
impl ::std::error::Error for HttpResponseCodeError {
        4580  +
impl ::std::error::Error for MalformedTimestampPathDefaultError {
 4955   4581   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 4956   4582   
        match &self {
 4957         -
            HttpResponseCodeError::InternalServerError(_inner) => Some(_inner),
        4583  +
            MalformedTimestampPathDefaultError::ValidationException(_inner) => Some(_inner),
        4584  +
            MalformedTimestampPathDefaultError::InternalServerError(_inner) => Some(_inner),
 4958   4585   
        }
 4959   4586   
    }
 4960   4587   
}
        4588  +
impl ::std::convert::From<crate::error::ValidationException>
        4589  +
    for crate::error::MalformedTimestampPathDefaultError
        4590  +
{
        4591  +
    fn from(
        4592  +
        variant: crate::error::ValidationException,
        4593  +
    ) -> crate::error::MalformedTimestampPathDefaultError {
        4594  +
        Self::ValidationException(variant)
        4595  +
    }
        4596  +
}
 4961   4597   
impl ::std::convert::From<crate::error::InternalServerError>
 4962         -
    for crate::error::HttpResponseCodeError
        4598  +
    for crate::error::MalformedTimestampPathDefaultError
 4963   4599   
{
 4964         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpResponseCodeError {
        4600  +
    fn from(
        4601  +
        variant: crate::error::InternalServerError,
        4602  +
    ) -> crate::error::MalformedTimestampPathDefaultError {
 4965   4603   
        Self::InternalServerError(variant)
 4966   4604   
    }
 4967   4605   
}
 4968   4606   
 4969         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpResponseCodeError {
 4970         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpResponseCodeError {
        4607  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampPathDefaultError {
        4608  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampPathDefaultError {
 4971   4609   
        ::pyo3::Python::with_gil(|py| {
 4972   4610   
            let error = variant.value(py);
 4973         -
        4611  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4612  +
                return error.into();
        4613  +
            }
 4974   4614   
            crate::error::InternalServerError {
 4975   4615   
                message: error.to_string(),
 4976   4616   
            }
 4977   4617   
            .into()
 4978   4618   
        })
 4979   4619   
    }
 4980   4620   
}
 4981   4621   
 4982         -
/// Error type for the `HttpPayloadWithUnion` operation.
 4983         -
/// Each variant represents an error that can occur for the `HttpPayloadWithUnion` operation.
        4622  +
/// Error type for the `MalformedTimestampPathHttpDate` operation.
        4623  +
/// Each variant represents an error that can occur for the `MalformedTimestampPathHttpDate` operation.
 4984   4624   
#[derive(::std::fmt::Debug)]
 4985         -
pub enum HttpPayloadWithUnionError {
        4625  +
pub enum MalformedTimestampPathHttpDateError {
        4626  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4627  +
    ValidationException(crate::error::ValidationException),
 4986   4628   
    #[allow(missing_docs)] // documentation missing in model
 4987   4629   
    InternalServerError(crate::error::InternalServerError),
 4988   4630   
}
 4989         -
impl ::std::fmt::Display for HttpPayloadWithUnionError {
        4631  +
impl ::std::fmt::Display for MalformedTimestampPathHttpDateError {
 4990   4632   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 4991   4633   
        match &self {
 4992         -
            HttpPayloadWithUnionError::InternalServerError(_inner) => _inner.fmt(f),
        4634  +
            MalformedTimestampPathHttpDateError::ValidationException(_inner) => _inner.fmt(f),
        4635  +
            MalformedTimestampPathHttpDateError::InternalServerError(_inner) => _inner.fmt(f),
 4993   4636   
        }
 4994   4637   
    }
 4995   4638   
}
 4996         -
impl HttpPayloadWithUnionError {
 4997         -
    /// Returns `true` if the error kind is `HttpPayloadWithUnionError::InternalServerError`.
 4998         -
    pub fn is_internal_server_error(&self) -> bool {
 4999         -
        matches!(&self, HttpPayloadWithUnionError::InternalServerError(_))
 5000         -
    }
 5001         -
    /// Returns the error name string by matching the correct variant.
 5002         -
    pub fn name(&self) -> &'static str {
 5003         -
        match &self {
 5004         -
            HttpPayloadWithUnionError::InternalServerError(_inner) => _inner.name(),
 5005         -
        }
        4639  +
impl MalformedTimestampPathHttpDateError {
        4640  +
    /// Returns `true` if the error kind is `MalformedTimestampPathHttpDateError::ValidationException`.
        4641  +
    pub fn is_validation_exception(&self) -> bool {
        4642  +
        matches!(
        4643  +
            &self,
        4644  +
            MalformedTimestampPathHttpDateError::ValidationException(_)
        4645  +
        )
        4646  +
    }
        4647  +
    /// Returns `true` if the error kind is `MalformedTimestampPathHttpDateError::InternalServerError`.
        4648  +
    pub fn is_internal_server_error(&self) -> bool {
        4649  +
        matches!(
        4650  +
            &self,
        4651  +
            MalformedTimestampPathHttpDateError::InternalServerError(_)
        4652  +
        )
        4653  +
    }
        4654  +
    /// Returns the error name string by matching the correct variant.
        4655  +
    pub fn name(&self) -> &'static str {
        4656  +
        match &self {
        4657  +
            MalformedTimestampPathHttpDateError::ValidationException(_inner) => _inner.name(),
        4658  +
            MalformedTimestampPathHttpDateError::InternalServerError(_inner) => _inner.name(),
        4659  +
        }
 5006   4660   
    }
 5007   4661   
}
 5008         -
impl ::std::error::Error for HttpPayloadWithUnionError {
        4662  +
impl ::std::error::Error for MalformedTimestampPathHttpDateError {
 5009   4663   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5010   4664   
        match &self {
 5011         -
            HttpPayloadWithUnionError::InternalServerError(_inner) => Some(_inner),
        4665  +
            MalformedTimestampPathHttpDateError::ValidationException(_inner) => Some(_inner),
        4666  +
            MalformedTimestampPathHttpDateError::InternalServerError(_inner) => Some(_inner),
 5012   4667   
        }
 5013   4668   
    }
 5014   4669   
}
        4670  +
impl ::std::convert::From<crate::error::ValidationException>
        4671  +
    for crate::error::MalformedTimestampPathHttpDateError
        4672  +
{
        4673  +
    fn from(
        4674  +
        variant: crate::error::ValidationException,
        4675  +
    ) -> crate::error::MalformedTimestampPathHttpDateError {
        4676  +
        Self::ValidationException(variant)
        4677  +
    }
        4678  +
}
 5015   4679   
impl ::std::convert::From<crate::error::InternalServerError>
 5016         -
    for crate::error::HttpPayloadWithUnionError
        4680  +
    for crate::error::MalformedTimestampPathHttpDateError
 5017   4681   
{
 5018         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpPayloadWithUnionError {
        4682  +
    fn from(
        4683  +
        variant: crate::error::InternalServerError,
        4684  +
    ) -> crate::error::MalformedTimestampPathHttpDateError {
 5019   4685   
        Self::InternalServerError(variant)
 5020   4686   
    }
 5021   4687   
}
 5022   4688   
 5023         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadWithUnionError {
 5024         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadWithUnionError {
        4689  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampPathHttpDateError {
        4690  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampPathHttpDateError {
 5025   4691   
        ::pyo3::Python::with_gil(|py| {
 5026   4692   
            let error = variant.value(py);
 5027         -
        4693  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4694  +
                return error.into();
        4695  +
            }
 5028   4696   
            crate::error::InternalServerError {
 5029   4697   
                message: error.to_string(),
 5030   4698   
            }
 5031   4699   
            .into()
 5032   4700   
        })
 5033   4701   
    }
 5034   4702   
}
 5035   4703   
 5036         -
/// Error type for the `HttpStringPayload` operation.
 5037         -
/// Each variant represents an error that can occur for the `HttpStringPayload` operation.
        4704  +
/// Error type for the `MalformedTimestampPathEpoch` operation.
        4705  +
/// Each variant represents an error that can occur for the `MalformedTimestampPathEpoch` operation.
 5038   4706   
#[derive(::std::fmt::Debug)]
 5039         -
pub enum HttpStringPayloadError {
        4707  +
pub enum MalformedTimestampPathEpochError {
        4708  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4709  +
    ValidationException(crate::error::ValidationException),
 5040   4710   
    #[allow(missing_docs)] // documentation missing in model
 5041   4711   
    InternalServerError(crate::error::InternalServerError),
 5042   4712   
}
 5043         -
impl ::std::fmt::Display for HttpStringPayloadError {
        4713  +
impl ::std::fmt::Display for MalformedTimestampPathEpochError {
 5044   4714   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5045   4715   
        match &self {
 5046         -
            HttpStringPayloadError::InternalServerError(_inner) => _inner.fmt(f),
        4716  +
            MalformedTimestampPathEpochError::ValidationException(_inner) => _inner.fmt(f),
        4717  +
            MalformedTimestampPathEpochError::InternalServerError(_inner) => _inner.fmt(f),
 5047   4718   
        }
 5048   4719   
    }
 5049   4720   
}
 5050         -
impl HttpStringPayloadError {
 5051         -
    /// Returns `true` if the error kind is `HttpStringPayloadError::InternalServerError`.
        4721  +
impl MalformedTimestampPathEpochError {
        4722  +
    /// Returns `true` if the error kind is `MalformedTimestampPathEpochError::ValidationException`.
        4723  +
    pub fn is_validation_exception(&self) -> bool {
        4724  +
        matches!(
        4725  +
            &self,
        4726  +
            MalformedTimestampPathEpochError::ValidationException(_)
        4727  +
        )
        4728  +
    }
        4729  +
    /// Returns `true` if the error kind is `MalformedTimestampPathEpochError::InternalServerError`.
 5052   4730   
    pub fn is_internal_server_error(&self) -> bool {
 5053         -
        matches!(&self, HttpStringPayloadError::InternalServerError(_))
        4731  +
        matches!(
        4732  +
            &self,
        4733  +
            MalformedTimestampPathEpochError::InternalServerError(_)
        4734  +
        )
 5054   4735   
    }
 5055   4736   
    /// Returns the error name string by matching the correct variant.
 5056   4737   
    pub fn name(&self) -> &'static str {
 5057   4738   
        match &self {
 5058         -
            HttpStringPayloadError::InternalServerError(_inner) => _inner.name(),
        4739  +
            MalformedTimestampPathEpochError::ValidationException(_inner) => _inner.name(),
        4740  +
            MalformedTimestampPathEpochError::InternalServerError(_inner) => _inner.name(),
 5059   4741   
        }
 5060   4742   
    }
 5061   4743   
}
 5062         -
impl ::std::error::Error for HttpStringPayloadError {
        4744  +
impl ::std::error::Error for MalformedTimestampPathEpochError {
 5063   4745   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5064   4746   
        match &self {
 5065         -
            HttpStringPayloadError::InternalServerError(_inner) => Some(_inner),
        4747  +
            MalformedTimestampPathEpochError::ValidationException(_inner) => Some(_inner),
        4748  +
            MalformedTimestampPathEpochError::InternalServerError(_inner) => Some(_inner),
 5066   4749   
        }
 5067   4750   
    }
 5068   4751   
}
        4752  +
impl ::std::convert::From<crate::error::ValidationException>
        4753  +
    for crate::error::MalformedTimestampPathEpochError
        4754  +
{
        4755  +
    fn from(
        4756  +
        variant: crate::error::ValidationException,
        4757  +
    ) -> crate::error::MalformedTimestampPathEpochError {
        4758  +
        Self::ValidationException(variant)
        4759  +
    }
        4760  +
}
 5069   4761   
impl ::std::convert::From<crate::error::InternalServerError>
 5070         -
    for crate::error::HttpStringPayloadError
        4762  +
    for crate::error::MalformedTimestampPathEpochError
 5071   4763   
{
 5072         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpStringPayloadError {
        4764  +
    fn from(
        4765  +
        variant: crate::error::InternalServerError,
        4766  +
    ) -> crate::error::MalformedTimestampPathEpochError {
 5073   4767   
        Self::InternalServerError(variant)
 5074   4768   
    }
 5075   4769   
}
 5076   4770   
 5077         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpStringPayloadError {
 5078         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpStringPayloadError {
        4771  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampPathEpochError {
        4772  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampPathEpochError {
 5079   4773   
        ::pyo3::Python::with_gil(|py| {
 5080   4774   
            let error = variant.value(py);
 5081         -
        4775  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4776  +
                return error.into();
        4777  +
            }
 5082   4778   
            crate::error::InternalServerError {
 5083   4779   
                message: error.to_string(),
 5084   4780   
            }
 5085   4781   
            .into()
 5086   4782   
        })
 5087   4783   
    }
 5088   4784   
}
 5089   4785   
 5090         -
/// Error type for the `HttpEnumPayload` operation.
 5091         -
/// Each variant represents an error that can occur for the `HttpEnumPayload` operation.
        4786  +
/// Error type for the `MalformedTimestampQueryDefault` operation.
        4787  +
/// Each variant represents an error that can occur for the `MalformedTimestampQueryDefault` operation.
 5092   4788   
#[derive(::std::fmt::Debug)]
 5093         -
pub enum HttpEnumPayloadError {
        4789  +
pub enum MalformedTimestampQueryDefaultError {
 5094   4790   
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 5095   4791   
    ValidationException(crate::error::ValidationException),
 5096   4792   
    #[allow(missing_docs)] // documentation missing in model
 5097   4793   
    InternalServerError(crate::error::InternalServerError),
 5098   4794   
}
 5099         -
impl ::std::fmt::Display for HttpEnumPayloadError {
        4795  +
impl ::std::fmt::Display for MalformedTimestampQueryDefaultError {
 5100   4796   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5101   4797   
        match &self {
 5102         -
            HttpEnumPayloadError::ValidationException(_inner) => _inner.fmt(f),
 5103         -
            HttpEnumPayloadError::InternalServerError(_inner) => _inner.fmt(f),
        4798  +
            MalformedTimestampQueryDefaultError::ValidationException(_inner) => _inner.fmt(f),
        4799  +
            MalformedTimestampQueryDefaultError::InternalServerError(_inner) => _inner.fmt(f),
 5104   4800   
        }
 5105   4801   
    }
 5106   4802   
}
 5107         -
impl HttpEnumPayloadError {
 5108         -
    /// Returns `true` if the error kind is `HttpEnumPayloadError::ValidationException`.
        4803  +
impl MalformedTimestampQueryDefaultError {
        4804  +
    /// Returns `true` if the error kind is `MalformedTimestampQueryDefaultError::ValidationException`.
 5109   4805   
    pub fn is_validation_exception(&self) -> bool {
 5110         -
        matches!(&self, HttpEnumPayloadError::ValidationException(_))
        4806  +
        matches!(
        4807  +
            &self,
        4808  +
            MalformedTimestampQueryDefaultError::ValidationException(_)
        4809  +
        )
 5111   4810   
    }
 5112         -
    /// Returns `true` if the error kind is `HttpEnumPayloadError::InternalServerError`.
        4811  +
    /// Returns `true` if the error kind is `MalformedTimestampQueryDefaultError::InternalServerError`.
 5113   4812   
    pub fn is_internal_server_error(&self) -> bool {
 5114         -
        matches!(&self, HttpEnumPayloadError::InternalServerError(_))
        4813  +
        matches!(
        4814  +
            &self,
        4815  +
            MalformedTimestampQueryDefaultError::InternalServerError(_)
        4816  +
        )
 5115   4817   
    }
 5116   4818   
    /// Returns the error name string by matching the correct variant.
 5117   4819   
    pub fn name(&self) -> &'static str {
 5118   4820   
        match &self {
 5119         -
            HttpEnumPayloadError::ValidationException(_inner) => _inner.name(),
 5120         -
            HttpEnumPayloadError::InternalServerError(_inner) => _inner.name(),
        4821  +
            MalformedTimestampQueryDefaultError::ValidationException(_inner) => _inner.name(),
        4822  +
            MalformedTimestampQueryDefaultError::InternalServerError(_inner) => _inner.name(),
 5121   4823   
        }
 5122   4824   
    }
 5123   4825   
}
 5124         -
impl ::std::error::Error for HttpEnumPayloadError {
        4826  +
impl ::std::error::Error for MalformedTimestampQueryDefaultError {
 5125   4827   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5126   4828   
        match &self {
 5127         -
            HttpEnumPayloadError::ValidationException(_inner) => Some(_inner),
 5128         -
            HttpEnumPayloadError::InternalServerError(_inner) => Some(_inner),
        4829  +
            MalformedTimestampQueryDefaultError::ValidationException(_inner) => Some(_inner),
        4830  +
            MalformedTimestampQueryDefaultError::InternalServerError(_inner) => Some(_inner),
 5129   4831   
        }
 5130   4832   
    }
 5131   4833   
}
 5132   4834   
impl ::std::convert::From<crate::error::ValidationException>
 5133         -
    for crate::error::HttpEnumPayloadError
        4835  +
    for crate::error::MalformedTimestampQueryDefaultError
 5134   4836   
{
 5135         -
    fn from(variant: crate::error::ValidationException) -> crate::error::HttpEnumPayloadError {
        4837  +
    fn from(
        4838  +
        variant: crate::error::ValidationException,
        4839  +
    ) -> crate::error::MalformedTimestampQueryDefaultError {
 5136   4840   
        Self::ValidationException(variant)
 5137   4841   
    }
 5138   4842   
}
 5139   4843   
impl ::std::convert::From<crate::error::InternalServerError>
 5140         -
    for crate::error::HttpEnumPayloadError
        4844  +
    for crate::error::MalformedTimestampQueryDefaultError
 5141   4845   
{
 5142         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpEnumPayloadError {
        4846  +
    fn from(
        4847  +
        variant: crate::error::InternalServerError,
        4848  +
    ) -> crate::error::MalformedTimestampQueryDefaultError {
 5143   4849   
        Self::InternalServerError(variant)
 5144   4850   
    }
 5145   4851   
}
 5146   4852   
 5147         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpEnumPayloadError {
 5148         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpEnumPayloadError {
        4853  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampQueryDefaultError {
        4854  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampQueryDefaultError {
 5149   4855   
        ::pyo3::Python::with_gil(|py| {
 5150   4856   
            let error = variant.value(py);
 5151   4857   
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 5152   4858   
                return error.into();
 5153   4859   
            }
 5154   4860   
            crate::error::InternalServerError {
 5155   4861   
                message: error.to_string(),
 5156   4862   
            }
 5157   4863   
            .into()
 5158   4864   
        })
 5159   4865   
    }
 5160   4866   
}
 5161   4867   
 5162         -
/// Error type for the `HttpPayloadWithStructure` operation.
 5163         -
/// Each variant represents an error that can occur for the `HttpPayloadWithStructure` operation.
        4868  +
/// Error type for the `MalformedTimestampQueryHttpDate` operation.
        4869  +
/// Each variant represents an error that can occur for the `MalformedTimestampQueryHttpDate` operation.
 5164   4870   
#[derive(::std::fmt::Debug)]
 5165         -
pub enum HttpPayloadWithStructureError {
        4871  +
pub enum MalformedTimestampQueryHttpDateError {
        4872  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4873  +
    ValidationException(crate::error::ValidationException),
 5166   4874   
    #[allow(missing_docs)] // documentation missing in model
 5167   4875   
    InternalServerError(crate::error::InternalServerError),
 5168   4876   
}
 5169         -
impl ::std::fmt::Display for HttpPayloadWithStructureError {
        4877  +
impl ::std::fmt::Display for MalformedTimestampQueryHttpDateError {
 5170   4878   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5171   4879   
        match &self {
 5172         -
            HttpPayloadWithStructureError::InternalServerError(_inner) => _inner.fmt(f),
        4880  +
            MalformedTimestampQueryHttpDateError::ValidationException(_inner) => _inner.fmt(f),
        4881  +
            MalformedTimestampQueryHttpDateError::InternalServerError(_inner) => _inner.fmt(f),
 5173   4882   
        }
 5174   4883   
    }
 5175   4884   
}
 5176         -
impl HttpPayloadWithStructureError {
 5177         -
    /// Returns `true` if the error kind is `HttpPayloadWithStructureError::InternalServerError`.
        4885  +
impl MalformedTimestampQueryHttpDateError {
        4886  +
    /// Returns `true` if the error kind is `MalformedTimestampQueryHttpDateError::ValidationException`.
        4887  +
    pub fn is_validation_exception(&self) -> bool {
        4888  +
        matches!(
        4889  +
            &self,
        4890  +
            MalformedTimestampQueryHttpDateError::ValidationException(_)
        4891  +
        )
        4892  +
    }
        4893  +
    /// Returns `true` if the error kind is `MalformedTimestampQueryHttpDateError::InternalServerError`.
 5178   4894   
    pub fn is_internal_server_error(&self) -> bool {
 5179         -
        matches!(&self, HttpPayloadWithStructureError::InternalServerError(_))
        4895  +
        matches!(
        4896  +
            &self,
        4897  +
            MalformedTimestampQueryHttpDateError::InternalServerError(_)
        4898  +
        )
 5180   4899   
    }
 5181   4900   
    /// Returns the error name string by matching the correct variant.
 5182   4901   
    pub fn name(&self) -> &'static str {
 5183   4902   
        match &self {
 5184         -
            HttpPayloadWithStructureError::InternalServerError(_inner) => _inner.name(),
        4903  +
            MalformedTimestampQueryHttpDateError::ValidationException(_inner) => _inner.name(),
        4904  +
            MalformedTimestampQueryHttpDateError::InternalServerError(_inner) => _inner.name(),
 5185   4905   
        }
 5186   4906   
    }
 5187   4907   
}
 5188         -
impl ::std::error::Error for HttpPayloadWithStructureError {
        4908  +
impl ::std::error::Error for MalformedTimestampQueryHttpDateError {
 5189   4909   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5190   4910   
        match &self {
 5191         -
            HttpPayloadWithStructureError::InternalServerError(_inner) => Some(_inner),
        4911  +
            MalformedTimestampQueryHttpDateError::ValidationException(_inner) => Some(_inner),
        4912  +
            MalformedTimestampQueryHttpDateError::InternalServerError(_inner) => Some(_inner),
 5192   4913   
        }
 5193   4914   
    }
 5194   4915   
}
        4916  +
impl ::std::convert::From<crate::error::ValidationException>
        4917  +
    for crate::error::MalformedTimestampQueryHttpDateError
        4918  +
{
        4919  +
    fn from(
        4920  +
        variant: crate::error::ValidationException,
        4921  +
    ) -> crate::error::MalformedTimestampQueryHttpDateError {
        4922  +
        Self::ValidationException(variant)
        4923  +
    }
        4924  +
}
 5195   4925   
impl ::std::convert::From<crate::error::InternalServerError>
 5196         -
    for crate::error::HttpPayloadWithStructureError
        4926  +
    for crate::error::MalformedTimestampQueryHttpDateError
 5197   4927   
{
 5198   4928   
    fn from(
 5199   4929   
        variant: crate::error::InternalServerError,
 5200         -
    ) -> crate::error::HttpPayloadWithStructureError {
        4930  +
    ) -> crate::error::MalformedTimestampQueryHttpDateError {
 5201   4931   
        Self::InternalServerError(variant)
 5202   4932   
    }
 5203   4933   
}
 5204   4934   
 5205         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadWithStructureError {
 5206         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadWithStructureError {
        4935  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampQueryHttpDateError {
        4936  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampQueryHttpDateError {
 5207   4937   
        ::pyo3::Python::with_gil(|py| {
 5208   4938   
            let error = variant.value(py);
 5209         -
        4939  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        4940  +
                return error.into();
        4941  +
            }
 5210   4942   
            crate::error::InternalServerError {
 5211   4943   
                message: error.to_string(),
 5212   4944   
            }
 5213   4945   
            .into()
 5214   4946   
        })
 5215   4947   
    }
 5216   4948   
}
 5217   4949   
 5218         -
/// Error type for the `HttpPayloadTraitsWithMediaType` operation.
 5219         -
/// Each variant represents an error that can occur for the `HttpPayloadTraitsWithMediaType` operation.
        4950  +
/// Error type for the `MalformedTimestampQueryEpoch` operation.
        4951  +
/// Each variant represents an error that can occur for the `MalformedTimestampQueryEpoch` operation.
 5220   4952   
#[derive(::std::fmt::Debug)]
 5221         -
pub enum HttpPayloadTraitsWithMediaTypeError {
        4953  +
pub enum MalformedTimestampQueryEpochError {
        4954  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        4955  +
    ValidationException(crate::error::ValidationException),
 5222   4956   
    #[allow(missing_docs)] // documentation missing in model
 5223   4957   
    InternalServerError(crate::error::InternalServerError),
 5224   4958   
}
 5225         -
impl ::std::fmt::Display for HttpPayloadTraitsWithMediaTypeError {
        4959  +
impl ::std::fmt::Display for MalformedTimestampQueryEpochError {
 5226   4960   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5227   4961   
        match &self {
 5228         -
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.fmt(f),
        4962  +
            MalformedTimestampQueryEpochError::ValidationException(_inner) => _inner.fmt(f),
        4963  +
            MalformedTimestampQueryEpochError::InternalServerError(_inner) => _inner.fmt(f),
 5229   4964   
        }
 5230   4965   
    }
 5231   4966   
}
 5232         -
impl HttpPayloadTraitsWithMediaTypeError {
 5233         -
    /// Returns `true` if the error kind is `HttpPayloadTraitsWithMediaTypeError::InternalServerError`.
        4967  +
impl MalformedTimestampQueryEpochError {
        4968  +
    /// Returns `true` if the error kind is `MalformedTimestampQueryEpochError::ValidationException`.
        4969  +
    pub fn is_validation_exception(&self) -> bool {
        4970  +
        matches!(
        4971  +
            &self,
        4972  +
            MalformedTimestampQueryEpochError::ValidationException(_)
        4973  +
        )
        4974  +
    }
        4975  +
    /// Returns `true` if the error kind is `MalformedTimestampQueryEpochError::InternalServerError`.
 5234   4976   
    pub fn is_internal_server_error(&self) -> bool {
 5235   4977   
        matches!(
 5236   4978   
            &self,
 5237         -
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_)
        4979  +
            MalformedTimestampQueryEpochError::InternalServerError(_)
 5238   4980   
        )
 5239   4981   
    }
 5240   4982   
    /// Returns the error name string by matching the correct variant.
 5241   4983   
    pub fn name(&self) -> &'static str {
 5242   4984   
        match &self {
 5243         -
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_inner) => _inner.name(),
        4985  +
            MalformedTimestampQueryEpochError::ValidationException(_inner) => _inner.name(),
        4986  +
            MalformedTimestampQueryEpochError::InternalServerError(_inner) => _inner.name(),
 5244   4987   
        }
 5245   4988   
    }
 5246   4989   
}
 5247         -
impl ::std::error::Error for HttpPayloadTraitsWithMediaTypeError {
        4990  +
impl ::std::error::Error for MalformedTimestampQueryEpochError {
 5248   4991   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5249   4992   
        match &self {
 5250         -
            HttpPayloadTraitsWithMediaTypeError::InternalServerError(_inner) => Some(_inner),
        4993  +
            MalformedTimestampQueryEpochError::ValidationException(_inner) => Some(_inner),
        4994  +
            MalformedTimestampQueryEpochError::InternalServerError(_inner) => Some(_inner),
 5251   4995   
        }
 5252   4996   
    }
 5253   4997   
}
 5254         -
impl ::std::convert::From<crate::error::InternalServerError>
 5255         -
    for crate::error::HttpPayloadTraitsWithMediaTypeError
        4998  +
impl ::std::convert::From<crate::error::ValidationException>
        4999  +
    for crate::error::MalformedTimestampQueryEpochError
        5000  +
{
        5001  +
    fn from(
        5002  +
        variant: crate::error::ValidationException,
        5003  +
    ) -> crate::error::MalformedTimestampQueryEpochError {
        5004  +
        Self::ValidationException(variant)
        5005  +
    }
        5006  +
}
        5007  +
impl ::std::convert::From<crate::error::InternalServerError>
        5008  +
    for crate::error::MalformedTimestampQueryEpochError
 5256   5009   
{
 5257   5010   
    fn from(
 5258   5011   
        variant: crate::error::InternalServerError,
 5259         -
    ) -> crate::error::HttpPayloadTraitsWithMediaTypeError {
        5012  +
    ) -> crate::error::MalformedTimestampQueryEpochError {
 5260   5013   
        Self::InternalServerError(variant)
 5261   5014   
    }
 5262   5015   
}
 5263   5016   
 5264         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadTraitsWithMediaTypeError {
 5265         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadTraitsWithMediaTypeError {
        5017  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampQueryEpochError {
        5018  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampQueryEpochError {
 5266   5019   
        ::pyo3::Python::with_gil(|py| {
 5267   5020   
            let error = variant.value(py);
 5268         -
        5021  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        5022  +
                return error.into();
        5023  +
            }
 5269   5024   
            crate::error::InternalServerError {
 5270   5025   
                message: error.to_string(),
 5271   5026   
            }
 5272   5027   
            .into()
 5273   5028   
        })
 5274   5029   
    }
 5275   5030   
}
 5276   5031   
 5277         -
/// Error type for the `HttpPayloadTraits` operation.
 5278         -
/// Each variant represents an error that can occur for the `HttpPayloadTraits` operation.
        5032  +
/// Error type for the `MalformedTimestampHeaderDefault` operation.
        5033  +
/// Each variant represents an error that can occur for the `MalformedTimestampHeaderDefault` operation.
 5279   5034   
#[derive(::std::fmt::Debug)]
 5280         -
pub enum HttpPayloadTraitsError {
        5035  +
pub enum MalformedTimestampHeaderDefaultError {
        5036  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        5037  +
    ValidationException(crate::error::ValidationException),
 5281   5038   
    #[allow(missing_docs)] // documentation missing in model
 5282   5039   
    InternalServerError(crate::error::InternalServerError),
 5283   5040   
}
 5284         -
impl ::std::fmt::Display for HttpPayloadTraitsError {
        5041  +
impl ::std::fmt::Display for MalformedTimestampHeaderDefaultError {
 5285   5042   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5286   5043   
        match &self {
 5287         -
            HttpPayloadTraitsError::InternalServerError(_inner) => _inner.fmt(f),
        5044  +
            MalformedTimestampHeaderDefaultError::ValidationException(_inner) => _inner.fmt(f),
        5045  +
            MalformedTimestampHeaderDefaultError::InternalServerError(_inner) => _inner.fmt(f),
 5288   5046   
        }
 5289   5047   
    }
 5290   5048   
}
 5291         -
impl HttpPayloadTraitsError {
 5292         -
    /// Returns `true` if the error kind is `HttpPayloadTraitsError::InternalServerError`.
        5049  +
impl MalformedTimestampHeaderDefaultError {
        5050  +
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDefaultError::ValidationException`.
        5051  +
    pub fn is_validation_exception(&self) -> bool {
        5052  +
        matches!(
        5053  +
            &self,
        5054  +
            MalformedTimestampHeaderDefaultError::ValidationException(_)
        5055  +
        )
        5056  +
    }
        5057  +
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDefaultError::InternalServerError`.
 5293   5058   
    pub fn is_internal_server_error(&self) -> bool {
 5294         -
        matches!(&self, HttpPayloadTraitsError::InternalServerError(_))
        5059  +
        matches!(
        5060  +
            &self,
        5061  +
            MalformedTimestampHeaderDefaultError::InternalServerError(_)
        5062  +
        )
 5295   5063   
    }
 5296   5064   
    /// Returns the error name string by matching the correct variant.
 5297   5065   
    pub fn name(&self) -> &'static str {
 5298   5066   
        match &self {
 5299         -
            HttpPayloadTraitsError::InternalServerError(_inner) => _inner.name(),
        5067  +
            MalformedTimestampHeaderDefaultError::ValidationException(_inner) => _inner.name(),
        5068  +
            MalformedTimestampHeaderDefaultError::InternalServerError(_inner) => _inner.name(),
 5300   5069   
        }
 5301   5070   
    }
 5302   5071   
}
 5303         -
impl ::std::error::Error for HttpPayloadTraitsError {
        5072  +
impl ::std::error::Error for MalformedTimestampHeaderDefaultError {
 5304   5073   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5305   5074   
        match &self {
 5306         -
            HttpPayloadTraitsError::InternalServerError(_inner) => Some(_inner),
        5075  +
            MalformedTimestampHeaderDefaultError::ValidationException(_inner) => Some(_inner),
        5076  +
            MalformedTimestampHeaderDefaultError::InternalServerError(_inner) => Some(_inner),
 5307   5077   
        }
 5308   5078   
    }
 5309   5079   
}
        5080  +
impl ::std::convert::From<crate::error::ValidationException>
        5081  +
    for crate::error::MalformedTimestampHeaderDefaultError
        5082  +
{
        5083  +
    fn from(
        5084  +
        variant: crate::error::ValidationException,
        5085  +
    ) -> crate::error::MalformedTimestampHeaderDefaultError {
        5086  +
        Self::ValidationException(variant)
        5087  +
    }
        5088  +
}
 5310   5089   
impl ::std::convert::From<crate::error::InternalServerError>
 5311         -
    for crate::error::HttpPayloadTraitsError
        5090  +
    for crate::error::MalformedTimestampHeaderDefaultError
 5312   5091   
{
 5313         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpPayloadTraitsError {
        5092  +
    fn from(
        5093  +
        variant: crate::error::InternalServerError,
        5094  +
    ) -> crate::error::MalformedTimestampHeaderDefaultError {
 5314   5095   
        Self::InternalServerError(variant)
 5315   5096   
    }
 5316   5097   
}
 5317   5098   
 5318         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadTraitsError {
 5319         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadTraitsError {
        5099  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampHeaderDefaultError {
        5100  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampHeaderDefaultError {
 5320   5101   
        ::pyo3::Python::with_gil(|py| {
 5321   5102   
            let error = variant.value(py);
 5322         -
        5103  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        5104  +
                return error.into();
        5105  +
            }
 5323   5106   
            crate::error::InternalServerError {
 5324   5107   
                message: error.to_string(),
 5325   5108   
            }
 5326   5109   
            .into()
 5327   5110   
        })
 5328   5111   
    }
 5329   5112   
}
 5330   5113   
 5331         -
/// Error type for the `HttpEmptyPrefixHeaders` operation.
 5332         -
/// Each variant represents an error that can occur for the `HttpEmptyPrefixHeaders` operation.
        5114  +
/// Error type for the `MalformedTimestampHeaderDateTime` operation.
        5115  +
/// Each variant represents an error that can occur for the `MalformedTimestampHeaderDateTime` operation.
 5333   5116   
#[derive(::std::fmt::Debug)]
 5334         -
pub enum HttpEmptyPrefixHeadersError {
        5117  +
pub enum MalformedTimestampHeaderDateTimeError {
        5118  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        5119  +
    ValidationException(crate::error::ValidationException),
 5335   5120   
    #[allow(missing_docs)] // documentation missing in model
 5336   5121   
    InternalServerError(crate::error::InternalServerError),
 5337   5122   
}
 5338         -
impl ::std::fmt::Display for HttpEmptyPrefixHeadersError {
        5123  +
impl ::std::fmt::Display for MalformedTimestampHeaderDateTimeError {
 5339   5124   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5340   5125   
        match &self {
 5341         -
            HttpEmptyPrefixHeadersError::InternalServerError(_inner) => _inner.fmt(f),
        5126  +
            MalformedTimestampHeaderDateTimeError::ValidationException(_inner) => _inner.fmt(f),
        5127  +
            MalformedTimestampHeaderDateTimeError::InternalServerError(_inner) => _inner.fmt(f),
 5342   5128   
        }
 5343   5129   
    }
 5344   5130   
}
 5345         -
impl HttpEmptyPrefixHeadersError {
 5346         -
    /// Returns `true` if the error kind is `HttpEmptyPrefixHeadersError::InternalServerError`.
        5131  +
impl MalformedTimestampHeaderDateTimeError {
        5132  +
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDateTimeError::ValidationException`.
        5133  +
    pub fn is_validation_exception(&self) -> bool {
        5134  +
        matches!(
        5135  +
            &self,
        5136  +
            MalformedTimestampHeaderDateTimeError::ValidationException(_)
        5137  +
        )
        5138  +
    }
        5139  +
    /// Returns `true` if the error kind is `MalformedTimestampHeaderDateTimeError::InternalServerError`.
 5347   5140   
    pub fn is_internal_server_error(&self) -> bool {
 5348         -
        matches!(&self, HttpEmptyPrefixHeadersError::InternalServerError(_))
        5141  +
        matches!(
        5142  +
            &self,
        5143  +
            MalformedTimestampHeaderDateTimeError::InternalServerError(_)
        5144  +
        )
 5349   5145   
    }
 5350   5146   
    /// Returns the error name string by matching the correct variant.
 5351   5147   
    pub fn name(&self) -> &'static str {
 5352   5148   
        match &self {
 5353         -
            HttpEmptyPrefixHeadersError::InternalServerError(_inner) => _inner.name(),
        5149  +
            MalformedTimestampHeaderDateTimeError::ValidationException(_inner) => _inner.name(),
        5150  +
            MalformedTimestampHeaderDateTimeError::InternalServerError(_inner) => _inner.name(),
 5354   5151   
        }
 5355   5152   
    }
 5356   5153   
}
 5357         -
impl ::std::error::Error for HttpEmptyPrefixHeadersError {
        5154  +
impl ::std::error::Error for MalformedTimestampHeaderDateTimeError {
 5358   5155   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5359   5156   
        match &self {
 5360         -
            HttpEmptyPrefixHeadersError::InternalServerError(_inner) => Some(_inner),
        5157  +
            MalformedTimestampHeaderDateTimeError::ValidationException(_inner) => Some(_inner),
        5158  +
            MalformedTimestampHeaderDateTimeError::InternalServerError(_inner) => Some(_inner),
 5361   5159   
        }
 5362   5160   
    }
 5363   5161   
}
        5162  +
impl ::std::convert::From<crate::error::ValidationException>
        5163  +
    for crate::error::MalformedTimestampHeaderDateTimeError
        5164  +
{
        5165  +
    fn from(
        5166  +
        variant: crate::error::ValidationException,
        5167  +
    ) -> crate::error::MalformedTimestampHeaderDateTimeError {
        5168  +
        Self::ValidationException(variant)
        5169  +
    }
        5170  +
}
 5364   5171   
impl ::std::convert::From<crate::error::InternalServerError>
 5365         -
    for crate::error::HttpEmptyPrefixHeadersError
        5172  +
    for crate::error::MalformedTimestampHeaderDateTimeError
 5366   5173   
{
 5367   5174   
    fn from(
 5368   5175   
        variant: crate::error::InternalServerError,
 5369         -
    ) -> crate::error::HttpEmptyPrefixHeadersError {
        5176  +
    ) -> crate::error::MalformedTimestampHeaderDateTimeError {
 5370   5177   
        Self::InternalServerError(variant)
 5371   5178   
    }
 5372   5179   
}
 5373   5180   
 5374         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpEmptyPrefixHeadersError {
 5375         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpEmptyPrefixHeadersError {
        5181  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampHeaderDateTimeError {
        5182  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampHeaderDateTimeError {
 5376   5183   
        ::pyo3::Python::with_gil(|py| {
 5377   5184   
            let error = variant.value(py);
 5378         -
        5185  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        5186  +
                return error.into();
        5187  +
            }
 5379   5188   
            crate::error::InternalServerError {
 5380   5189   
                message: error.to_string(),
 5381   5190   
            }
 5382   5191   
            .into()
 5383   5192   
        })
 5384   5193   
    }
 5385   5194   
}
 5386   5195   
 5387         -
/// Error type for the `HttpPrefixHeadersInResponse` operation.
 5388         -
/// Each variant represents an error that can occur for the `HttpPrefixHeadersInResponse` operation.
        5196  +
/// Error type for the `MalformedTimestampHeaderEpoch` operation.
        5197  +
/// Each variant represents an error that can occur for the `MalformedTimestampHeaderEpoch` operation.
 5389   5198   
#[derive(::std::fmt::Debug)]
 5390         -
pub enum HttpPrefixHeadersInResponseError {
        5199  +
pub enum MalformedTimestampHeaderEpochError {
        5200  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        5201  +
    ValidationException(crate::error::ValidationException),
 5391   5202   
    #[allow(missing_docs)] // documentation missing in model
 5392   5203   
    InternalServerError(crate::error::InternalServerError),
 5393   5204   
}
 5394         -
impl ::std::fmt::Display for HttpPrefixHeadersInResponseError {
        5205  +
impl ::std::fmt::Display for MalformedTimestampHeaderEpochError {
 5395   5206   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5396   5207   
        match &self {
 5397         -
            HttpPrefixHeadersInResponseError::InternalServerError(_inner) => _inner.fmt(f),
        5208  +
            MalformedTimestampHeaderEpochError::ValidationException(_inner) => _inner.fmt(f),
        5209  +
            MalformedTimestampHeaderEpochError::InternalServerError(_inner) => _inner.fmt(f),
 5398   5210   
        }
 5399   5211   
    }
 5400   5212   
}
 5401         -
impl HttpPrefixHeadersInResponseError {
 5402         -
    /// Returns `true` if the error kind is `HttpPrefixHeadersInResponseError::InternalServerError`.
        5213  +
impl MalformedTimestampHeaderEpochError {
        5214  +
    /// Returns `true` if the error kind is `MalformedTimestampHeaderEpochError::ValidationException`.
        5215  +
    pub fn is_validation_exception(&self) -> bool {
        5216  +
        matches!(
        5217  +
            &self,
        5218  +
            MalformedTimestampHeaderEpochError::ValidationException(_)
        5219  +
        )
        5220  +
    }
        5221  +
    /// Returns `true` if the error kind is `MalformedTimestampHeaderEpochError::InternalServerError`.
 5403   5222   
    pub fn is_internal_server_error(&self) -> bool {
 5404   5223   
        matches!(
 5405   5224   
            &self,
 5406         -
            HttpPrefixHeadersInResponseError::InternalServerError(_)
        5225  +
            MalformedTimestampHeaderEpochError::InternalServerError(_)
 5407   5226   
        )
 5408   5227   
    }
 5409   5228   
    /// Returns the error name string by matching the correct variant.
 5410   5229   
    pub fn name(&self) -> &'static str {
 5411   5230   
        match &self {
 5412         -
            HttpPrefixHeadersInResponseError::InternalServerError(_inner) => _inner.name(),
        5231  +
            MalformedTimestampHeaderEpochError::ValidationException(_inner) => _inner.name(),
        5232  +
            MalformedTimestampHeaderEpochError::InternalServerError(_inner) => _inner.name(),
 5413   5233   
        }
 5414   5234   
    }
 5415   5235   
}
 5416         -
impl ::std::error::Error for HttpPrefixHeadersInResponseError {
        5236  +
impl ::std::error::Error for MalformedTimestampHeaderEpochError {
 5417   5237   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5418   5238   
        match &self {
 5419         -
            HttpPrefixHeadersInResponseError::InternalServerError(_inner) => Some(_inner),
        5239  +
            MalformedTimestampHeaderEpochError::ValidationException(_inner) => Some(_inner),
        5240  +
            MalformedTimestampHeaderEpochError::InternalServerError(_inner) => Some(_inner),
 5420   5241   
        }
 5421   5242   
    }
 5422   5243   
}
        5244  +
impl ::std::convert::From<crate::error::ValidationException>
        5245  +
    for crate::error::MalformedTimestampHeaderEpochError
        5246  +
{
        5247  +
    fn from(
        5248  +
        variant: crate::error::ValidationException,
        5249  +
    ) -> crate::error::MalformedTimestampHeaderEpochError {
        5250  +
        Self::ValidationException(variant)
        5251  +
    }
        5252  +
}
 5423   5253   
impl ::std::convert::From<crate::error::InternalServerError>
 5424         -
    for crate::error::HttpPrefixHeadersInResponseError
        5254  +
    for crate::error::MalformedTimestampHeaderEpochError
 5425   5255   
{
 5426   5256   
    fn from(
 5427   5257   
        variant: crate::error::InternalServerError,
 5428         -
    ) -> crate::error::HttpPrefixHeadersInResponseError {
        5258  +
    ) -> crate::error::MalformedTimestampHeaderEpochError {
 5429   5259   
        Self::InternalServerError(variant)
 5430   5260   
    }
 5431   5261   
}
 5432   5262   
 5433         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPrefixHeadersInResponseError {
 5434         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPrefixHeadersInResponseError {
        5263  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampHeaderEpochError {
        5264  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampHeaderEpochError {
 5435   5265   
        ::pyo3::Python::with_gil(|py| {
 5436   5266   
            let error = variant.value(py);
 5437         -
        5267  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        5268  +
                return error.into();
        5269  +
            }
 5438   5270   
            crate::error::InternalServerError {
 5439   5271   
                message: error.to_string(),
 5440   5272   
            }
 5441   5273   
            .into()
 5442   5274   
        })
 5443   5275   
    }
 5444   5276   
}
 5445   5277   
 5446         -
/// Error type for the `HttpPrefixHeaders` operation.
 5447         -
/// Each variant represents an error that can occur for the `HttpPrefixHeaders` operation.
        5278  +
/// Error type for the `MalformedTimestampBodyDefault` operation.
        5279  +
/// Each variant represents an error that can occur for the `MalformedTimestampBodyDefault` operation.
 5448   5280   
#[derive(::std::fmt::Debug)]
 5449         -
pub enum HttpPrefixHeadersError {
        5281  +
pub enum MalformedTimestampBodyDefaultError {
        5282  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        5283  +
    ValidationException(crate::error::ValidationException),
 5450   5284   
    #[allow(missing_docs)] // documentation missing in model
 5451   5285   
    InternalServerError(crate::error::InternalServerError),
 5452   5286   
}
 5453         -
impl ::std::fmt::Display for HttpPrefixHeadersError {
        5287  +
impl ::std::fmt::Display for MalformedTimestampBodyDefaultError {
 5454   5288   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5455   5289   
        match &self {
 5456         -
            HttpPrefixHeadersError::InternalServerError(_inner) => _inner.fmt(f),
        5290  +
            MalformedTimestampBodyDefaultError::ValidationException(_inner) => _inner.fmt(f),
        5291  +
            MalformedTimestampBodyDefaultError::InternalServerError(_inner) => _inner.fmt(f),
 5457   5292   
        }
 5458   5293   
    }
 5459   5294   
}
 5460         -
impl HttpPrefixHeadersError {
 5461         -
    /// Returns `true` if the error kind is `HttpPrefixHeadersError::InternalServerError`.
        5295  +
impl MalformedTimestampBodyDefaultError {
        5296  +
    /// Returns `true` if the error kind is `MalformedTimestampBodyDefaultError::ValidationException`.
        5297  +
    pub fn is_validation_exception(&self) -> bool {
        5298  +
        matches!(
        5299  +
            &self,
        5300  +
            MalformedTimestampBodyDefaultError::ValidationException(_)
        5301  +
        )
        5302  +
    }
        5303  +
    /// Returns `true` if the error kind is `MalformedTimestampBodyDefaultError::InternalServerError`.
 5462   5304   
    pub fn is_internal_server_error(&self) -> bool {
 5463         -
        matches!(&self, HttpPrefixHeadersError::InternalServerError(_))
        5305  +
        matches!(
        5306  +
            &self,
        5307  +
            MalformedTimestampBodyDefaultError::InternalServerError(_)
        5308  +
        )
 5464   5309   
    }
 5465   5310   
    /// Returns the error name string by matching the correct variant.
 5466   5311   
    pub fn name(&self) -> &'static str {
 5467   5312   
        match &self {
 5468         -
            HttpPrefixHeadersError::InternalServerError(_inner) => _inner.name(),
        5313  +
            MalformedTimestampBodyDefaultError::ValidationException(_inner) => _inner.name(),
        5314  +
            MalformedTimestampBodyDefaultError::InternalServerError(_inner) => _inner.name(),
 5469   5315   
        }
 5470   5316   
    }
 5471   5317   
}
 5472         -
impl ::std::error::Error for HttpPrefixHeadersError {
        5318  +
impl ::std::error::Error for MalformedTimestampBodyDefaultError {
 5473   5319   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5474   5320   
        match &self {
 5475         -
            HttpPrefixHeadersError::InternalServerError(_inner) => Some(_inner),
        5321  +
            MalformedTimestampBodyDefaultError::ValidationException(_inner) => Some(_inner),
        5322  +
            MalformedTimestampBodyDefaultError::InternalServerError(_inner) => Some(_inner),
 5476   5323   
        }
 5477   5324   
    }
 5478   5325   
}
        5326  +
impl ::std::convert::From<crate::error::ValidationException>
        5327  +
    for crate::error::MalformedTimestampBodyDefaultError
        5328  +
{
        5329  +
    fn from(
        5330  +
        variant: crate::error::ValidationException,
        5331  +
    ) -> crate::error::MalformedTimestampBodyDefaultError {
        5332  +
        Self::ValidationException(variant)
        5333  +
    }
        5334  +
}
 5479   5335   
impl ::std::convert::From<crate::error::InternalServerError>
 5480         -
    for crate::error::HttpPrefixHeadersError
        5336  +
    for crate::error::MalformedTimestampBodyDefaultError
 5481   5337   
{
 5482         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::HttpPrefixHeadersError {
        5338  +
    fn from(
        5339  +
        variant: crate::error::InternalServerError,
        5340  +
    ) -> crate::error::MalformedTimestampBodyDefaultError {
 5483   5341   
        Self::InternalServerError(variant)
 5484   5342   
    }
 5485   5343   
}
 5486   5344   
 5487         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPrefixHeadersError {
 5488         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPrefixHeadersError {
        5345  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampBodyDefaultError {
        5346  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampBodyDefaultError {
 5489   5347   
        ::pyo3::Python::with_gil(|py| {
 5490   5348   
            let error = variant.value(py);
 5491         -
        5349  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        5350  +
                return error.into();
        5351  +
            }
 5492   5352   
            crate::error::InternalServerError {
 5493   5353   
                message: error.to_string(),
 5494   5354   
            }
 5495   5355   
            .into()
 5496   5356   
        })
 5497   5357   
    }
 5498   5358   
}
 5499   5359   
 5500         -
/// Error type for the `QueryParamsAsStringListMap` operation.
 5501         -
/// Each variant represents an error that can occur for the `QueryParamsAsStringListMap` operation.
        5360  +
/// Error type for the `MalformedTimestampBodyDateTime` operation.
        5361  +
/// Each variant represents an error that can occur for the `MalformedTimestampBodyDateTime` operation.
 5502   5362   
#[derive(::std::fmt::Debug)]
 5503         -
pub enum QueryParamsAsStringListMapError {
        5363  +
pub enum MalformedTimestampBodyDateTimeError {
        5364  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        5365  +
    ValidationException(crate::error::ValidationException),
 5504   5366   
    #[allow(missing_docs)] // documentation missing in model
 5505   5367   
    InternalServerError(crate::error::InternalServerError),
 5506   5368   
}
 5507         -
impl ::std::fmt::Display for QueryParamsAsStringListMapError {
        5369  +
impl ::std::fmt::Display for MalformedTimestampBodyDateTimeError {
 5508   5370   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5509   5371   
        match &self {
 5510         -
            QueryParamsAsStringListMapError::InternalServerError(_inner) => _inner.fmt(f),
        5372  +
            MalformedTimestampBodyDateTimeError::ValidationException(_inner) => _inner.fmt(f),
        5373  +
            MalformedTimestampBodyDateTimeError::InternalServerError(_inner) => _inner.fmt(f),
 5511   5374   
        }
 5512   5375   
    }
 5513   5376   
}
 5514         -
impl QueryParamsAsStringListMapError {
 5515         -
    /// Returns `true` if the error kind is `QueryParamsAsStringListMapError::InternalServerError`.
        5377  +
impl MalformedTimestampBodyDateTimeError {
        5378  +
    /// Returns `true` if the error kind is `MalformedTimestampBodyDateTimeError::ValidationException`.
        5379  +
    pub fn is_validation_exception(&self) -> bool {
        5380  +
        matches!(
        5381  +
            &self,
        5382  +
            MalformedTimestampBodyDateTimeError::ValidationException(_)
        5383  +
        )
        5384  +
    }
        5385  +
    /// Returns `true` if the error kind is `MalformedTimestampBodyDateTimeError::InternalServerError`.
 5516   5386   
    pub fn is_internal_server_error(&self) -> bool {
 5517   5387   
        matches!(
 5518   5388   
            &self,
 5519         -
            QueryParamsAsStringListMapError::InternalServerError(_)
        5389  +
            MalformedTimestampBodyDateTimeError::InternalServerError(_)
 5520   5390   
        )
 5521   5391   
    }
 5522   5392   
    /// Returns the error name string by matching the correct variant.
 5523   5393   
    pub fn name(&self) -> &'static str {
 5524   5394   
        match &self {
 5525         -
            QueryParamsAsStringListMapError::InternalServerError(_inner) => _inner.name(),
        5395  +
            MalformedTimestampBodyDateTimeError::ValidationException(_inner) => _inner.name(),
        5396  +
            MalformedTimestampBodyDateTimeError::InternalServerError(_inner) => _inner.name(),
 5526   5397   
        }
 5527   5398   
    }
 5528   5399   
}
 5529         -
impl ::std::error::Error for QueryParamsAsStringListMapError {
        5400  +
impl ::std::error::Error for MalformedTimestampBodyDateTimeError {
 5530   5401   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5531   5402   
        match &self {
 5532         -
            QueryParamsAsStringListMapError::InternalServerError(_inner) => Some(_inner),
        5403  +
            MalformedTimestampBodyDateTimeError::ValidationException(_inner) => Some(_inner),
        5404  +
            MalformedTimestampBodyDateTimeError::InternalServerError(_inner) => Some(_inner),
 5533   5405   
        }
 5534   5406   
    }
 5535   5407   
}
        5408  +
impl ::std::convert::From<crate::error::ValidationException>
        5409  +
    for crate::error::MalformedTimestampBodyDateTimeError
        5410  +
{
        5411  +
    fn from(
        5412  +
        variant: crate::error::ValidationException,
        5413  +
    ) -> crate::error::MalformedTimestampBodyDateTimeError {
        5414  +
        Self::ValidationException(variant)
        5415  +
    }
        5416  +
}
 5536   5417   
impl ::std::convert::From<crate::error::InternalServerError>
 5537         -
    for crate::error::QueryParamsAsStringListMapError
        5418  +
    for crate::error::MalformedTimestampBodyDateTimeError
 5538   5419   
{
 5539   5420   
    fn from(
 5540   5421   
        variant: crate::error::InternalServerError,
 5541         -
    ) -> crate::error::QueryParamsAsStringListMapError {
        5422  +
    ) -> crate::error::MalformedTimestampBodyDateTimeError {
 5542   5423   
        Self::InternalServerError(variant)
 5543   5424   
    }
 5544   5425   
}
 5545   5426   
 5546         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryParamsAsStringListMapError {
 5547         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::QueryParamsAsStringListMapError {
        5427  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampBodyDateTimeError {
        5428  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampBodyDateTimeError {
 5548   5429   
        ::pyo3::Python::with_gil(|py| {
 5549   5430   
            let error = variant.value(py);
 5550         -
        5431  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        5432  +
                return error.into();
        5433  +
            }
 5551   5434   
            crate::error::InternalServerError {
 5552   5435   
                message: error.to_string(),
 5553   5436   
            }
 5554   5437   
            .into()
 5555   5438   
        })
 5556   5439   
    }
 5557   5440   
}
 5558   5441   
 5559         -
/// Error type for the `QueryPrecedence` operation.
 5560         -
/// Each variant represents an error that can occur for the `QueryPrecedence` operation.
        5442  +
/// Error type for the `MalformedTimestampBodyHttpDate` operation.
        5443  +
/// Each variant represents an error that can occur for the `MalformedTimestampBodyHttpDate` operation.
 5561   5444   
#[derive(::std::fmt::Debug)]
 5562         -
pub enum QueryPrecedenceError {
        5445  +
pub enum MalformedTimestampBodyHttpDateError {
        5446  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        5447  +
    ValidationException(crate::error::ValidationException),
 5563   5448   
    #[allow(missing_docs)] // documentation missing in model
 5564   5449   
    InternalServerError(crate::error::InternalServerError),
 5565   5450   
}
 5566         -
impl ::std::fmt::Display for QueryPrecedenceError {
        5451  +
impl ::std::fmt::Display for MalformedTimestampBodyHttpDateError {
 5567   5452   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5568   5453   
        match &self {
 5569         -
            QueryPrecedenceError::InternalServerError(_inner) => _inner.fmt(f),
        5454  +
            MalformedTimestampBodyHttpDateError::ValidationException(_inner) => _inner.fmt(f),
        5455  +
            MalformedTimestampBodyHttpDateError::InternalServerError(_inner) => _inner.fmt(f),
 5570   5456   
        }
 5571   5457   
    }
 5572   5458   
}
 5573         -
impl QueryPrecedenceError {
 5574         -
    /// Returns `true` if the error kind is `QueryPrecedenceError::InternalServerError`.
        5459  +
impl MalformedTimestampBodyHttpDateError {
        5460  +
    /// Returns `true` if the error kind is `MalformedTimestampBodyHttpDateError::ValidationException`.
        5461  +
    pub fn is_validation_exception(&self) -> bool {
        5462  +
        matches!(
        5463  +
            &self,
        5464  +
            MalformedTimestampBodyHttpDateError::ValidationException(_)
        5465  +
        )
        5466  +
    }
        5467  +
    /// Returns `true` if the error kind is `MalformedTimestampBodyHttpDateError::InternalServerError`.
 5575   5468   
    pub fn is_internal_server_error(&self) -> bool {
 5576         -
        matches!(&self, QueryPrecedenceError::InternalServerError(_))
        5469  +
        matches!(
        5470  +
            &self,
        5471  +
            MalformedTimestampBodyHttpDateError::InternalServerError(_)
        5472  +
        )
 5577   5473   
    }
 5578   5474   
    /// Returns the error name string by matching the correct variant.
 5579   5475   
    pub fn name(&self) -> &'static str {
 5580   5476   
        match &self {
 5581         -
            QueryPrecedenceError::InternalServerError(_inner) => _inner.name(),
        5477  +
            MalformedTimestampBodyHttpDateError::ValidationException(_inner) => _inner.name(),
        5478  +
            MalformedTimestampBodyHttpDateError::InternalServerError(_inner) => _inner.name(),
 5582   5479   
        }
 5583   5480   
    }
 5584   5481   
}
 5585         -
impl ::std::error::Error for QueryPrecedenceError {
        5482  +
impl ::std::error::Error for MalformedTimestampBodyHttpDateError {
 5586   5483   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5587   5484   
        match &self {
 5588         -
            QueryPrecedenceError::InternalServerError(_inner) => Some(_inner),
        5485  +
            MalformedTimestampBodyHttpDateError::ValidationException(_inner) => Some(_inner),
        5486  +
            MalformedTimestampBodyHttpDateError::InternalServerError(_inner) => Some(_inner),
 5589   5487   
        }
 5590   5488   
    }
 5591   5489   
}
        5490  +
impl ::std::convert::From<crate::error::ValidationException>
        5491  +
    for crate::error::MalformedTimestampBodyHttpDateError
        5492  +
{
        5493  +
    fn from(
        5494  +
        variant: crate::error::ValidationException,
        5495  +
    ) -> crate::error::MalformedTimestampBodyHttpDateError {
        5496  +
        Self::ValidationException(variant)
        5497  +
    }
        5498  +
}
 5592   5499   
impl ::std::convert::From<crate::error::InternalServerError>
 5593         -
    for crate::error::QueryPrecedenceError
        5500  +
    for crate::error::MalformedTimestampBodyHttpDateError
 5594   5501   
{
 5595         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::QueryPrecedenceError {
        5502  +
    fn from(
        5503  +
        variant: crate::error::InternalServerError,
        5504  +
    ) -> crate::error::MalformedTimestampBodyHttpDateError {
 5596   5505   
        Self::InternalServerError(variant)
 5597   5506   
    }
 5598   5507   
}
 5599   5508   
 5600         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryPrecedenceError {
 5601         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::QueryPrecedenceError {
        5509  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedTimestampBodyHttpDateError {
        5510  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedTimestampBodyHttpDateError {
 5602   5511   
        ::pyo3::Python::with_gil(|py| {
 5603   5512   
            let error = variant.value(py);
 5604         -
        5513  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        5514  +
                return error.into();
        5515  +
            }
 5605   5516   
            crate::error::InternalServerError {
 5606   5517   
                message: error.to_string(),
 5607   5518   
            }
 5608   5519   
            .into()
 5609   5520   
        })
 5610   5521   
    }
 5611   5522   
}
 5612   5523   
 5613         -
/// Error type for the `QueryIdempotencyTokenAutoFill` operation.
 5614         -
/// Each variant represents an error that can occur for the `QueryIdempotencyTokenAutoFill` operation.
        5524  +
/// Error type for the `MalformedContentTypeWithoutBody` operation.
        5525  +
/// Each variant represents an error that can occur for the `MalformedContentTypeWithoutBody` operation.
 5615   5526   
#[derive(::std::fmt::Debug)]
 5616         -
pub enum QueryIdempotencyTokenAutoFillError {
        5527  +
pub enum MalformedContentTypeWithoutBodyError {
 5617   5528   
    #[allow(missing_docs)] // documentation missing in model
 5618   5529   
    InternalServerError(crate::error::InternalServerError),
 5619   5530   
}
 5620         -
impl ::std::fmt::Display for QueryIdempotencyTokenAutoFillError {
        5531  +
impl ::std::fmt::Display for MalformedContentTypeWithoutBodyError {
 5621   5532   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5622   5533   
        match &self {
 5623         -
            QueryIdempotencyTokenAutoFillError::InternalServerError(_inner) => _inner.fmt(f),
        5534  +
            MalformedContentTypeWithoutBodyError::InternalServerError(_inner) => _inner.fmt(f),
 5624   5535   
        }
 5625   5536   
    }
 5626   5537   
}
 5627         -
impl QueryIdempotencyTokenAutoFillError {
 5628         -
    /// Returns `true` if the error kind is `QueryIdempotencyTokenAutoFillError::InternalServerError`.
        5538  +
impl MalformedContentTypeWithoutBodyError {
        5539  +
    /// Returns `true` if the error kind is `MalformedContentTypeWithoutBodyError::InternalServerError`.
 5629   5540   
    pub fn is_internal_server_error(&self) -> bool {
 5630   5541   
        matches!(
 5631   5542   
            &self,
 5632         -
            QueryIdempotencyTokenAutoFillError::InternalServerError(_)
        5543  +
            MalformedContentTypeWithoutBodyError::InternalServerError(_)
 5633   5544   
        )
 5634   5545   
    }
 5635   5546   
    /// Returns the error name string by matching the correct variant.
 5636   5547   
    pub fn name(&self) -> &'static str {
 5637   5548   
        match &self {
 5638         -
            QueryIdempotencyTokenAutoFillError::InternalServerError(_inner) => _inner.name(),
        5549  +
            MalformedContentTypeWithoutBodyError::InternalServerError(_inner) => _inner.name(),
 5639   5550   
        }
 5640   5551   
    }
 5641   5552   
}
 5642         -
impl ::std::error::Error for QueryIdempotencyTokenAutoFillError {
        5553  +
impl ::std::error::Error for MalformedContentTypeWithoutBodyError {
 5643   5554   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5644   5555   
        match &self {
 5645         -
            QueryIdempotencyTokenAutoFillError::InternalServerError(_inner) => Some(_inner),
        5556  +
            MalformedContentTypeWithoutBodyError::InternalServerError(_inner) => Some(_inner),
 5646   5557   
        }
 5647   5558   
    }
 5648   5559   
}
 5649   5560   
impl ::std::convert::From<crate::error::InternalServerError>
 5650         -
    for crate::error::QueryIdempotencyTokenAutoFillError
        5561  +
    for crate::error::MalformedContentTypeWithoutBodyError
 5651   5562   
{
 5652   5563   
    fn from(
 5653   5564   
        variant: crate::error::InternalServerError,
 5654         -
    ) -> crate::error::QueryIdempotencyTokenAutoFillError {
        5565  +
    ) -> crate::error::MalformedContentTypeWithoutBodyError {
 5655   5566   
        Self::InternalServerError(variant)
 5656   5567   
    }
 5657   5568   
}
 5658   5569   
 5659         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryIdempotencyTokenAutoFillError {
 5660         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::QueryIdempotencyTokenAutoFillError {
        5570  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedContentTypeWithoutBodyError {
        5571  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithoutBodyError {
 5661   5572   
        ::pyo3::Python::with_gil(|py| {
 5662   5573   
            let error = variant.value(py);
 5663   5574   
 5664   5575   
            crate::error::InternalServerError {
 5665   5576   
                message: error.to_string(),
 5666   5577   
            }
 5667   5578   
            .into()
 5668   5579   
        })
 5669   5580   
    }
 5670   5581   
}
 5671   5582   
 5672         -
/// Error type for the `OmitsSerializingEmptyLists` operation.
 5673         -
/// Each variant represents an error that can occur for the `OmitsSerializingEmptyLists` operation.
        5583  +
/// Error type for the `MalformedContentTypeWithoutBodyEmptyInput` operation.
        5584  +
/// Each variant represents an error that can occur for the `MalformedContentTypeWithoutBodyEmptyInput` operation.
 5674   5585   
#[derive(::std::fmt::Debug)]
 5675         -
pub enum OmitsSerializingEmptyListsError {
 5676         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 5677         -
    ValidationException(crate::error::ValidationException),
        5586  +
pub enum MalformedContentTypeWithoutBodyEmptyInputError {
 5678   5587   
    #[allow(missing_docs)] // documentation missing in model
 5679   5588   
    InternalServerError(crate::error::InternalServerError),
 5680   5589   
}
 5681         -
impl ::std::fmt::Display for OmitsSerializingEmptyListsError {
        5590  +
impl ::std::fmt::Display for MalformedContentTypeWithoutBodyEmptyInputError {
 5682   5591   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5683   5592   
        match &self {
 5684         -
            OmitsSerializingEmptyListsError::ValidationException(_inner) => _inner.fmt(f),
 5685         -
            OmitsSerializingEmptyListsError::InternalServerError(_inner) => _inner.fmt(f),
        5593  +
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_inner) => {
        5594  +
                _inner.fmt(f)
        5595  +
            }
 5686   5596   
        }
 5687   5597   
    }
 5688   5598   
}
 5689         -
impl OmitsSerializingEmptyListsError {
 5690         -
    /// Returns `true` if the error kind is `OmitsSerializingEmptyListsError::ValidationException`.
 5691         -
    pub fn is_validation_exception(&self) -> bool {
 5692         -
        matches!(
 5693         -
            &self,
 5694         -
            OmitsSerializingEmptyListsError::ValidationException(_)
 5695         -
        )
 5696         -
    }
 5697         -
    /// Returns `true` if the error kind is `OmitsSerializingEmptyListsError::InternalServerError`.
        5599  +
impl MalformedContentTypeWithoutBodyEmptyInputError {
        5600  +
    /// Returns `true` if the error kind is `MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError`.
 5698   5601   
    pub fn is_internal_server_error(&self) -> bool {
 5699   5602   
        matches!(
 5700   5603   
            &self,
 5701         -
            OmitsSerializingEmptyListsError::InternalServerError(_)
        5604  +
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_)
 5702   5605   
        )
 5703   5606   
    }
 5704   5607   
    /// Returns the error name string by matching the correct variant.
 5705   5608   
    pub fn name(&self) -> &'static str {
 5706   5609   
        match &self {
 5707         -
            OmitsSerializingEmptyListsError::ValidationException(_inner) => _inner.name(),
 5708         -
            OmitsSerializingEmptyListsError::InternalServerError(_inner) => _inner.name(),
        5610  +
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_inner) => {
        5611  +
                _inner.name()
        5612  +
            }
 5709   5613   
        }
 5710   5614   
    }
 5711   5615   
}
 5712         -
impl ::std::error::Error for OmitsSerializingEmptyListsError {
        5616  +
impl ::std::error::Error for MalformedContentTypeWithoutBodyEmptyInputError {
 5713   5617   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5714   5618   
        match &self {
 5715         -
            OmitsSerializingEmptyListsError::ValidationException(_inner) => Some(_inner),
 5716         -
            OmitsSerializingEmptyListsError::InternalServerError(_inner) => Some(_inner),
        5619  +
            MalformedContentTypeWithoutBodyEmptyInputError::InternalServerError(_inner) => {
        5620  +
                Some(_inner)
        5621  +
            }
 5717   5622   
        }
 5718   5623   
    }
 5719   5624   
}
 5720         -
impl ::std::convert::From<crate::error::ValidationException>
 5721         -
    for crate::error::OmitsSerializingEmptyListsError
 5722         -
{
 5723         -
    fn from(
 5724         -
        variant: crate::error::ValidationException,
 5725         -
    ) -> crate::error::OmitsSerializingEmptyListsError {
 5726         -
        Self::ValidationException(variant)
 5727         -
    }
 5728         -
}
 5729   5625   
impl ::std::convert::From<crate::error::InternalServerError>
 5730         -
    for crate::error::OmitsSerializingEmptyListsError
        5626  +
    for crate::error::MalformedContentTypeWithoutBodyEmptyInputError
 5731   5627   
{
 5732   5628   
    fn from(
 5733   5629   
        variant: crate::error::InternalServerError,
 5734         -
    ) -> crate::error::OmitsSerializingEmptyListsError {
        5630  +
    ) -> crate::error::MalformedContentTypeWithoutBodyEmptyInputError {
 5735   5631   
        Self::InternalServerError(variant)
 5736   5632   
    }
 5737   5633   
}
 5738   5634   
 5739         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OmitsSerializingEmptyListsError {
 5740         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::OmitsSerializingEmptyListsError {
        5635  +
impl ::std::convert::From<::pyo3::PyErr>
        5636  +
    for crate::error::MalformedContentTypeWithoutBodyEmptyInputError
        5637  +
{
        5638  +
    fn from(
        5639  +
        variant: ::pyo3::PyErr,
        5640  +
    ) -> crate::error::MalformedContentTypeWithoutBodyEmptyInputError {
 5741   5641   
        ::pyo3::Python::with_gil(|py| {
 5742   5642   
            let error = variant.value(py);
 5743         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 5744         -
                return error.into();
 5745         -
            }
        5643  +
 5746   5644   
            crate::error::InternalServerError {
 5747   5645   
                message: error.to_string(),
 5748   5646   
            }
 5749   5647   
            .into()
 5750   5648   
        })
 5751   5649   
    }
 5752   5650   
}
 5753   5651   
 5754         -
/// Error type for the `OmitsNullSerializesEmptyString` operation.
 5755         -
/// Each variant represents an error that can occur for the `OmitsNullSerializesEmptyString` operation.
        5652  +
/// Error type for the `MalformedContentTypeWithBody` operation.
        5653  +
/// Each variant represents an error that can occur for the `MalformedContentTypeWithBody` operation.
 5756   5654   
#[derive(::std::fmt::Debug)]
 5757         -
pub enum OmitsNullSerializesEmptyStringError {
        5655  +
pub enum MalformedContentTypeWithBodyError {
 5758   5656   
    #[allow(missing_docs)] // documentation missing in model
 5759   5657   
    InternalServerError(crate::error::InternalServerError),
 5760   5658   
}
 5761         -
impl ::std::fmt::Display for OmitsNullSerializesEmptyStringError {
        5659  +
impl ::std::fmt::Display for MalformedContentTypeWithBodyError {
 5762   5660   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5763   5661   
        match &self {
 5764         -
            OmitsNullSerializesEmptyStringError::InternalServerError(_inner) => _inner.fmt(f),
        5662  +
            MalformedContentTypeWithBodyError::InternalServerError(_inner) => _inner.fmt(f),
 5765   5663   
        }
 5766   5664   
    }
 5767   5665   
}
 5768         -
impl OmitsNullSerializesEmptyStringError {
 5769         -
    /// Returns `true` if the error kind is `OmitsNullSerializesEmptyStringError::InternalServerError`.
        5666  +
impl MalformedContentTypeWithBodyError {
        5667  +
    /// Returns `true` if the error kind is `MalformedContentTypeWithBodyError::InternalServerError`.
 5770   5668   
    pub fn is_internal_server_error(&self) -> bool {
 5771   5669   
        matches!(
 5772   5670   
            &self,
 5773         -
            OmitsNullSerializesEmptyStringError::InternalServerError(_)
        5671  +
            MalformedContentTypeWithBodyError::InternalServerError(_)
 5774   5672   
        )
 5775   5673   
    }
 5776   5674   
    /// Returns the error name string by matching the correct variant.
 5777   5675   
    pub fn name(&self) -> &'static str {
 5778   5676   
        match &self {
 5779         -
            OmitsNullSerializesEmptyStringError::InternalServerError(_inner) => _inner.name(),
        5677  +
            MalformedContentTypeWithBodyError::InternalServerError(_inner) => _inner.name(),
 5780   5678   
        }
 5781   5679   
    }
 5782   5680   
}
 5783         -
impl ::std::error::Error for OmitsNullSerializesEmptyStringError {
        5681  +
impl ::std::error::Error for MalformedContentTypeWithBodyError {
 5784   5682   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5785   5683   
        match &self {
 5786         -
            OmitsNullSerializesEmptyStringError::InternalServerError(_inner) => Some(_inner),
        5684  +
            MalformedContentTypeWithBodyError::InternalServerError(_inner) => Some(_inner),
 5787   5685   
        }
 5788   5686   
    }
 5789   5687   
}
 5790   5688   
impl ::std::convert::From<crate::error::InternalServerError>
 5791         -
    for crate::error::OmitsNullSerializesEmptyStringError
        5689  +
    for crate::error::MalformedContentTypeWithBodyError
 5792   5690   
{
 5793   5691   
    fn from(
 5794   5692   
        variant: crate::error::InternalServerError,
 5795         -
    ) -> crate::error::OmitsNullSerializesEmptyStringError {
        5693  +
    ) -> crate::error::MalformedContentTypeWithBodyError {
 5796   5694   
        Self::InternalServerError(variant)
 5797   5695   
    }
 5798   5696   
}
 5799   5697   
 5800         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OmitsNullSerializesEmptyStringError {
 5801         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::OmitsNullSerializesEmptyStringError {
        5698  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedContentTypeWithBodyError {
        5699  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithBodyError {
 5802   5700   
        ::pyo3::Python::with_gil(|py| {
 5803   5701   
            let error = variant.value(py);
 5804   5702   
 5805   5703   
            crate::error::InternalServerError {
 5806   5704   
                message: error.to_string(),
 5807   5705   
            }
 5808   5706   
            .into()
 5809   5707   
        })
 5810   5708   
    }
 5811   5709   
}
 5812   5710   
 5813         -
/// Error type for the `IgnoreQueryParamsInResponse` operation.
 5814         -
/// Each variant represents an error that can occur for the `IgnoreQueryParamsInResponse` operation.
        5711  +
/// Error type for the `MalformedContentTypeWithPayload` operation.
        5712  +
/// Each variant represents an error that can occur for the `MalformedContentTypeWithPayload` operation.
 5815   5713   
#[derive(::std::fmt::Debug)]
 5816         -
pub enum IgnoreQueryParamsInResponseError {
        5714  +
pub enum MalformedContentTypeWithPayloadError {
 5817   5715   
    #[allow(missing_docs)] // documentation missing in model
 5818   5716   
    InternalServerError(crate::error::InternalServerError),
 5819   5717   
}
 5820         -
impl ::std::fmt::Display for IgnoreQueryParamsInResponseError {
        5718  +
impl ::std::fmt::Display for MalformedContentTypeWithPayloadError {
 5821   5719   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5822   5720   
        match &self {
 5823         -
            IgnoreQueryParamsInResponseError::InternalServerError(_inner) => _inner.fmt(f),
        5721  +
            MalformedContentTypeWithPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 5824   5722   
        }
 5825   5723   
    }
 5826   5724   
}
 5827         -
impl IgnoreQueryParamsInResponseError {
 5828         -
    /// Returns `true` if the error kind is `IgnoreQueryParamsInResponseError::InternalServerError`.
        5725  +
impl MalformedContentTypeWithPayloadError {
        5726  +
    /// Returns `true` if the error kind is `MalformedContentTypeWithPayloadError::InternalServerError`.
 5829   5727   
    pub fn is_internal_server_error(&self) -> bool {
 5830   5728   
        matches!(
 5831   5729   
            &self,
 5832         -
            IgnoreQueryParamsInResponseError::InternalServerError(_)
        5730  +
            MalformedContentTypeWithPayloadError::InternalServerError(_)
 5833   5731   
        )
 5834   5732   
    }
 5835   5733   
    /// Returns the error name string by matching the correct variant.
 5836   5734   
    pub fn name(&self) -> &'static str {
 5837   5735   
        match &self {
 5838         -
            IgnoreQueryParamsInResponseError::InternalServerError(_inner) => _inner.name(),
        5736  +
            MalformedContentTypeWithPayloadError::InternalServerError(_inner) => _inner.name(),
 5839   5737   
        }
 5840   5738   
    }
 5841   5739   
}
 5842         -
impl ::std::error::Error for IgnoreQueryParamsInResponseError {
        5740  +
impl ::std::error::Error for MalformedContentTypeWithPayloadError {
 5843   5741   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5844   5742   
        match &self {
 5845         -
            IgnoreQueryParamsInResponseError::InternalServerError(_inner) => Some(_inner),
        5743  +
            MalformedContentTypeWithPayloadError::InternalServerError(_inner) => Some(_inner),
 5846   5744   
        }
 5847   5745   
    }
 5848   5746   
}
 5849   5747   
impl ::std::convert::From<crate::error::InternalServerError>
 5850         -
    for crate::error::IgnoreQueryParamsInResponseError
        5748  +
    for crate::error::MalformedContentTypeWithPayloadError
 5851   5749   
{
 5852   5750   
    fn from(
 5853   5751   
        variant: crate::error::InternalServerError,
 5854         -
    ) -> crate::error::IgnoreQueryParamsInResponseError {
        5752  +
    ) -> crate::error::MalformedContentTypeWithPayloadError {
 5855   5753   
        Self::InternalServerError(variant)
 5856   5754   
    }
 5857   5755   
}
 5858   5756   
 5859         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::IgnoreQueryParamsInResponseError {
 5860         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::IgnoreQueryParamsInResponseError {
        5757  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedContentTypeWithPayloadError {
        5758  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithPayloadError {
 5861   5759   
        ::pyo3::Python::with_gil(|py| {
 5862   5760   
            let error = variant.value(py);
 5863   5761   
 5864   5762   
            crate::error::InternalServerError {
 5865   5763   
                message: error.to_string(),
 5866   5764   
            }
 5867   5765   
            .into()
 5868   5766   
        })
 5869   5767   
    }
 5870   5768   
}
 5871   5769   
 5872         -
/// Error type for the `ConstantAndVariableQueryString` operation.
 5873         -
/// Each variant represents an error that can occur for the `ConstantAndVariableQueryString` operation.
        5770  +
/// Error type for the `MalformedContentTypeWithGenericString` operation.
        5771  +
/// Each variant represents an error that can occur for the `MalformedContentTypeWithGenericString` operation.
 5874   5772   
#[derive(::std::fmt::Debug)]
 5875         -
pub enum ConstantAndVariableQueryStringError {
        5773  +
pub enum MalformedContentTypeWithGenericStringError {
 5876   5774   
    #[allow(missing_docs)] // documentation missing in model
 5877   5775   
    InternalServerError(crate::error::InternalServerError),
 5878   5776   
}
 5879         -
impl ::std::fmt::Display for ConstantAndVariableQueryStringError {
        5777  +
impl ::std::fmt::Display for MalformedContentTypeWithGenericStringError {
 5880   5778   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5881   5779   
        match &self {
 5882         -
            ConstantAndVariableQueryStringError::InternalServerError(_inner) => _inner.fmt(f),
        5780  +
            MalformedContentTypeWithGenericStringError::InternalServerError(_inner) => {
        5781  +
                _inner.fmt(f)
        5782  +
            }
 5883   5783   
        }
 5884   5784   
    }
 5885   5785   
}
 5886         -
impl ConstantAndVariableQueryStringError {
 5887         -
    /// Returns `true` if the error kind is `ConstantAndVariableQueryStringError::InternalServerError`.
        5786  +
impl MalformedContentTypeWithGenericStringError {
        5787  +
    /// Returns `true` if the error kind is `MalformedContentTypeWithGenericStringError::InternalServerError`.
 5888   5788   
    pub fn is_internal_server_error(&self) -> bool {
 5889   5789   
        matches!(
 5890   5790   
            &self,
 5891         -
            ConstantAndVariableQueryStringError::InternalServerError(_)
        5791  +
            MalformedContentTypeWithGenericStringError::InternalServerError(_)
 5892   5792   
        )
 5893   5793   
    }
 5894   5794   
    /// Returns the error name string by matching the correct variant.
 5895   5795   
    pub fn name(&self) -> &'static str {
 5896   5796   
        match &self {
 5897         -
            ConstantAndVariableQueryStringError::InternalServerError(_inner) => _inner.name(),
        5797  +
            MalformedContentTypeWithGenericStringError::InternalServerError(_inner) => {
        5798  +
                _inner.name()
        5799  +
            }
 5898   5800   
        }
 5899   5801   
    }
 5900   5802   
}
 5901         -
impl ::std::error::Error for ConstantAndVariableQueryStringError {
        5803  +
impl ::std::error::Error for MalformedContentTypeWithGenericStringError {
 5902   5804   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5903   5805   
        match &self {
 5904         -
            ConstantAndVariableQueryStringError::InternalServerError(_inner) => Some(_inner),
        5806  +
            MalformedContentTypeWithGenericStringError::InternalServerError(_inner) => Some(_inner),
 5905   5807   
        }
 5906   5808   
    }
 5907   5809   
}
 5908   5810   
impl ::std::convert::From<crate::error::InternalServerError>
 5909         -
    for crate::error::ConstantAndVariableQueryStringError
        5811  +
    for crate::error::MalformedContentTypeWithGenericStringError
 5910   5812   
{
 5911   5813   
    fn from(
 5912   5814   
        variant: crate::error::InternalServerError,
 5913         -
    ) -> crate::error::ConstantAndVariableQueryStringError {
        5815  +
    ) -> crate::error::MalformedContentTypeWithGenericStringError {
 5914   5816   
        Self::InternalServerError(variant)
 5915   5817   
    }
 5916   5818   
}
 5917   5819   
 5918         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ConstantAndVariableQueryStringError {
 5919         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::ConstantAndVariableQueryStringError {
        5820  +
impl ::std::convert::From<::pyo3::PyErr>
        5821  +
    for crate::error::MalformedContentTypeWithGenericStringError
        5822  +
{
        5823  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithGenericStringError {
 5920   5824   
        ::pyo3::Python::with_gil(|py| {
 5921   5825   
            let error = variant.value(py);
 5922   5826   
 5923   5827   
            crate::error::InternalServerError {
 5924   5828   
                message: error.to_string(),
 5925   5829   
            }
 5926   5830   
            .into()
 5927   5831   
        })
 5928   5832   
    }
 5929   5833   
}
 5930   5834   
 5931         -
/// Error type for the `ConstantQueryString` operation.
 5932         -
/// Each variant represents an error that can occur for the `ConstantQueryString` operation.
        5835  +
/// Error type for the `MalformedAcceptWithBody` operation.
        5836  +
/// Each variant represents an error that can occur for the `MalformedAcceptWithBody` operation.
 5933   5837   
#[derive(::std::fmt::Debug)]
 5934         -
pub enum ConstantQueryStringError {
 5935         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 5936         -
    ValidationException(crate::error::ValidationException),
        5838  +
pub enum MalformedAcceptWithBodyError {
 5937   5839   
    #[allow(missing_docs)] // documentation missing in model
 5938   5840   
    InternalServerError(crate::error::InternalServerError),
 5939   5841   
}
 5940         -
impl ::std::fmt::Display for ConstantQueryStringError {
        5842  +
impl ::std::fmt::Display for MalformedAcceptWithBodyError {
 5941   5843   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 5942   5844   
        match &self {
 5943         -
            ConstantQueryStringError::ValidationException(_inner) => _inner.fmt(f),
 5944         -
            ConstantQueryStringError::InternalServerError(_inner) => _inner.fmt(f),
        5845  +
            MalformedAcceptWithBodyError::InternalServerError(_inner) => _inner.fmt(f),
 5945   5846   
        }
 5946   5847   
    }
 5947   5848   
}
 5948         -
impl ConstantQueryStringError {
 5949         -
    /// Returns `true` if the error kind is `ConstantQueryStringError::ValidationException`.
 5950         -
    pub fn is_validation_exception(&self) -> bool {
 5951         -
        matches!(&self, ConstantQueryStringError::ValidationException(_))
 5952         -
    }
 5953         -
    /// Returns `true` if the error kind is `ConstantQueryStringError::InternalServerError`.
        5849  +
impl MalformedAcceptWithBodyError {
        5850  +
    /// Returns `true` if the error kind is `MalformedAcceptWithBodyError::InternalServerError`.
 5954   5851   
    pub fn is_internal_server_error(&self) -> bool {
 5955         -
        matches!(&self, ConstantQueryStringError::InternalServerError(_))
        5852  +
        matches!(&self, MalformedAcceptWithBodyError::InternalServerError(_))
 5956   5853   
    }
 5957   5854   
    /// Returns the error name string by matching the correct variant.
 5958   5855   
    pub fn name(&self) -> &'static str {
 5959   5856   
        match &self {
 5960         -
            ConstantQueryStringError::ValidationException(_inner) => _inner.name(),
 5961         -
            ConstantQueryStringError::InternalServerError(_inner) => _inner.name(),
        5857  +
            MalformedAcceptWithBodyError::InternalServerError(_inner) => _inner.name(),
 5962   5858   
        }
 5963   5859   
    }
 5964   5860   
}
 5965         -
impl ::std::error::Error for ConstantQueryStringError {
        5861  +
impl ::std::error::Error for MalformedAcceptWithBodyError {
 5966   5862   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 5967   5863   
        match &self {
 5968         -
            ConstantQueryStringError::ValidationException(_inner) => Some(_inner),
 5969         -
            ConstantQueryStringError::InternalServerError(_inner) => Some(_inner),
        5864  +
            MalformedAcceptWithBodyError::InternalServerError(_inner) => Some(_inner),
 5970   5865   
        }
 5971   5866   
    }
 5972   5867   
}
 5973         -
impl ::std::convert::From<crate::error::ValidationException>
 5974         -
    for crate::error::ConstantQueryStringError
 5975         -
{
 5976         -
    fn from(variant: crate::error::ValidationException) -> crate::error::ConstantQueryStringError {
 5977         -
        Self::ValidationException(variant)
 5978         -
    }
 5979         -
}
 5980   5868   
impl ::std::convert::From<crate::error::InternalServerError>
 5981         -
    for crate::error::ConstantQueryStringError
        5869  +
    for crate::error::MalformedAcceptWithBodyError
 5982   5870   
{
 5983         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::ConstantQueryStringError {
        5871  +
    fn from(
        5872  +
        variant: crate::error::InternalServerError,
        5873  +
    ) -> crate::error::MalformedAcceptWithBodyError {
 5984   5874   
        Self::InternalServerError(variant)
 5985   5875   
    }
 5986   5876   
}
 5987   5877   
 5988         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ConstantQueryStringError {
 5989         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::ConstantQueryStringError {
        5878  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedAcceptWithBodyError {
        5879  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedAcceptWithBodyError {
 5990   5880   
        ::pyo3::Python::with_gil(|py| {
 5991   5881   
            let error = variant.value(py);
 5992         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 5993         -
                return error.into();
 5994         -
            }
        5882  +
 5995   5883   
            crate::error::InternalServerError {
 5996   5884   
                message: error.to_string(),
 5997   5885   
            }
 5998   5886   
            .into()
 5999   5887   
        })
 6000   5888   
    }
 6001   5889   
}
 6002   5890   
 6003         -
/// Error type for the `AllQueryStringTypes` operation.
 6004         -
/// Each variant represents an error that can occur for the `AllQueryStringTypes` operation.
        5891  +
/// Error type for the `MalformedAcceptWithPayload` operation.
        5892  +
/// Each variant represents an error that can occur for the `MalformedAcceptWithPayload` operation.
 6005   5893   
#[derive(::std::fmt::Debug)]
 6006         -
pub enum AllQueryStringTypesError {
 6007         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 6008         -
    ValidationException(crate::error::ValidationException),
        5894  +
pub enum MalformedAcceptWithPayloadError {
 6009   5895   
    #[allow(missing_docs)] // documentation missing in model
 6010   5896   
    InternalServerError(crate::error::InternalServerError),
 6011   5897   
}
 6012         -
impl ::std::fmt::Display for AllQueryStringTypesError {
        5898  +
impl ::std::fmt::Display for MalformedAcceptWithPayloadError {
 6013   5899   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6014   5900   
        match &self {
 6015         -
            AllQueryStringTypesError::ValidationException(_inner) => _inner.fmt(f),
 6016         -
            AllQueryStringTypesError::InternalServerError(_inner) => _inner.fmt(f),
        5901  +
            MalformedAcceptWithPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 6017   5902   
        }
 6018   5903   
    }
 6019   5904   
}
 6020         -
impl AllQueryStringTypesError {
 6021         -
    /// Returns `true` if the error kind is `AllQueryStringTypesError::ValidationException`.
 6022         -
    pub fn is_validation_exception(&self) -> bool {
 6023         -
        matches!(&self, AllQueryStringTypesError::ValidationException(_))
 6024         -
    }
 6025         -
    /// Returns `true` if the error kind is `AllQueryStringTypesError::InternalServerError`.
        5905  +
impl MalformedAcceptWithPayloadError {
        5906  +
    /// Returns `true` if the error kind is `MalformedAcceptWithPayloadError::InternalServerError`.
 6026   5907   
    pub fn is_internal_server_error(&self) -> bool {
 6027         -
        matches!(&self, AllQueryStringTypesError::InternalServerError(_))
        5908  +
        matches!(
        5909  +
            &self,
        5910  +
            MalformedAcceptWithPayloadError::InternalServerError(_)
        5911  +
        )
 6028   5912   
    }
 6029   5913   
    /// Returns the error name string by matching the correct variant.
 6030   5914   
    pub fn name(&self) -> &'static str {
 6031   5915   
        match &self {
 6032         -
            AllQueryStringTypesError::ValidationException(_inner) => _inner.name(),
 6033         -
            AllQueryStringTypesError::InternalServerError(_inner) => _inner.name(),
        5916  +
            MalformedAcceptWithPayloadError::InternalServerError(_inner) => _inner.name(),
 6034   5917   
        }
 6035   5918   
    }
 6036   5919   
}
 6037         -
impl ::std::error::Error for AllQueryStringTypesError {
        5920  +
impl ::std::error::Error for MalformedAcceptWithPayloadError {
 6038   5921   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6039   5922   
        match &self {
 6040         -
            AllQueryStringTypesError::ValidationException(_inner) => Some(_inner),
 6041         -
            AllQueryStringTypesError::InternalServerError(_inner) => Some(_inner),
        5923  +
            MalformedAcceptWithPayloadError::InternalServerError(_inner) => Some(_inner),
 6042   5924   
        }
 6043   5925   
    }
 6044   5926   
}
 6045         -
impl ::std::convert::From<crate::error::ValidationException>
 6046         -
    for crate::error::AllQueryStringTypesError
 6047         -
{
 6048         -
    fn from(variant: crate::error::ValidationException) -> crate::error::AllQueryStringTypesError {
 6049         -
        Self::ValidationException(variant)
 6050         -
    }
 6051         -
}
 6052   5927   
impl ::std::convert::From<crate::error::InternalServerError>
 6053         -
    for crate::error::AllQueryStringTypesError
        5928  +
    for crate::error::MalformedAcceptWithPayloadError
 6054   5929   
{
 6055         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::AllQueryStringTypesError {
        5930  +
    fn from(
        5931  +
        variant: crate::error::InternalServerError,
        5932  +
    ) -> crate::error::MalformedAcceptWithPayloadError {
 6056   5933   
        Self::InternalServerError(variant)
 6057   5934   
    }
 6058   5935   
}
 6059   5936   
 6060         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::AllQueryStringTypesError {
 6061         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::AllQueryStringTypesError {
        5937  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedAcceptWithPayloadError {
        5938  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedAcceptWithPayloadError {
 6062   5939   
        ::pyo3::Python::with_gil(|py| {
 6063   5940   
            let error = variant.value(py);
 6064         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 6065         -
                return error.into();
 6066         -
            }
        5941  +
 6067   5942   
            crate::error::InternalServerError {
 6068   5943   
                message: error.to_string(),
 6069   5944   
            }
 6070   5945   
            .into()
 6071   5946   
        })
 6072   5947   
    }
 6073   5948   
}
 6074   5949   
 6075         -
/// Error type for the `HttpRequestWithRegexLiteral` operation.
 6076         -
/// Each variant represents an error that can occur for the `HttpRequestWithRegexLiteral` operation.
        5950  +
/// Error type for the `MalformedAcceptWithGenericString` operation.
        5951  +
/// Each variant represents an error that can occur for the `MalformedAcceptWithGenericString` operation.
 6077   5952   
#[derive(::std::fmt::Debug)]
 6078         -
pub enum HttpRequestWithRegexLiteralError {
 6079         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 6080         -
    ValidationException(crate::error::ValidationException),
        5953  +
pub enum MalformedAcceptWithGenericStringError {
 6081   5954   
    #[allow(missing_docs)] // documentation missing in model
 6082   5955   
    InternalServerError(crate::error::InternalServerError),
 6083   5956   
}
 6084         -
impl ::std::fmt::Display for HttpRequestWithRegexLiteralError {
        5957  +
impl ::std::fmt::Display for MalformedAcceptWithGenericStringError {
 6085   5958   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6086   5959   
        match &self {
 6087         -
            HttpRequestWithRegexLiteralError::ValidationException(_inner) => _inner.fmt(f),
 6088         -
            HttpRequestWithRegexLiteralError::InternalServerError(_inner) => _inner.fmt(f),
        5960  +
            MalformedAcceptWithGenericStringError::InternalServerError(_inner) => _inner.fmt(f),
 6089   5961   
        }
 6090   5962   
    }
 6091   5963   
}
 6092         -
impl HttpRequestWithRegexLiteralError {
 6093         -
    /// Returns `true` if the error kind is `HttpRequestWithRegexLiteralError::ValidationException`.
 6094         -
    pub fn is_validation_exception(&self) -> bool {
 6095         -
        matches!(
 6096         -
            &self,
 6097         -
            HttpRequestWithRegexLiteralError::ValidationException(_)
 6098         -
        )
 6099         -
    }
 6100         -
    /// Returns `true` if the error kind is `HttpRequestWithRegexLiteralError::InternalServerError`.
        5964  +
impl MalformedAcceptWithGenericStringError {
        5965  +
    /// Returns `true` if the error kind is `MalformedAcceptWithGenericStringError::InternalServerError`.
 6101   5966   
    pub fn is_internal_server_error(&self) -> bool {
 6102   5967   
        matches!(
 6103   5968   
            &self,
 6104         -
            HttpRequestWithRegexLiteralError::InternalServerError(_)
        5969  +
            MalformedAcceptWithGenericStringError::InternalServerError(_)
 6105   5970   
        )
 6106   5971   
    }
 6107   5972   
    /// Returns the error name string by matching the correct variant.
 6108   5973   
    pub fn name(&self) -> &'static str {
 6109   5974   
        match &self {
 6110         -
            HttpRequestWithRegexLiteralError::ValidationException(_inner) => _inner.name(),
 6111         -
            HttpRequestWithRegexLiteralError::InternalServerError(_inner) => _inner.name(),
        5975  +
            MalformedAcceptWithGenericStringError::InternalServerError(_inner) => _inner.name(),
 6112   5976   
        }
 6113   5977   
    }
 6114   5978   
}
 6115         -
impl ::std::error::Error for HttpRequestWithRegexLiteralError {
        5979  +
impl ::std::error::Error for MalformedAcceptWithGenericStringError {
 6116   5980   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6117   5981   
        match &self {
 6118         -
            HttpRequestWithRegexLiteralError::ValidationException(_inner) => Some(_inner),
 6119         -
            HttpRequestWithRegexLiteralError::InternalServerError(_inner) => Some(_inner),
        5982  +
            MalformedAcceptWithGenericStringError::InternalServerError(_inner) => Some(_inner),
 6120   5983   
        }
 6121   5984   
    }
 6122   5985   
}
 6123         -
impl ::std::convert::From<crate::error::ValidationException>
 6124         -
    for crate::error::HttpRequestWithRegexLiteralError
 6125         -
{
 6126         -
    fn from(
 6127         -
        variant: crate::error::ValidationException,
 6128         -
    ) -> crate::error::HttpRequestWithRegexLiteralError {
 6129         -
        Self::ValidationException(variant)
 6130         -
    }
 6131         -
}
 6132   5986   
impl ::std::convert::From<crate::error::InternalServerError>
 6133         -
    for crate::error::HttpRequestWithRegexLiteralError
        5987  +
    for crate::error::MalformedAcceptWithGenericStringError
 6134   5988   
{
 6135   5989   
    fn from(
 6136   5990   
        variant: crate::error::InternalServerError,
 6137         -
    ) -> crate::error::HttpRequestWithRegexLiteralError {
        5991  +
    ) -> crate::error::MalformedAcceptWithGenericStringError {
 6138   5992   
        Self::InternalServerError(variant)
 6139   5993   
    }
 6140   5994   
}
 6141   5995   
 6142         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithRegexLiteralError {
 6143         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithRegexLiteralError {
        5996  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedAcceptWithGenericStringError {
        5997  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedAcceptWithGenericStringError {
 6144   5998   
        ::pyo3::Python::with_gil(|py| {
 6145   5999   
            let error = variant.value(py);
 6146         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 6147         -
                return error.into();
 6148         -
            }
        6000  +
 6149   6001   
            crate::error::InternalServerError {
 6150   6002   
                message: error.to_string(),
 6151   6003   
            }
 6152   6004   
            .into()
 6153   6005   
        })
 6154   6006   
    }
 6155   6007   
}
 6156   6008   
 6157         -
/// Error type for the `HttpRequestWithFloatLabels` operation.
 6158         -
/// Each variant represents an error that can occur for the `HttpRequestWithFloatLabels` operation.
        6009  +
/// Error type for the `TestBodyStructure` operation.
        6010  +
/// Each variant represents an error that can occur for the `TestBodyStructure` operation.
 6159   6011   
#[derive(::std::fmt::Debug)]
 6160         -
pub enum HttpRequestWithFloatLabelsError {
 6161         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 6162         -
    ValidationException(crate::error::ValidationException),
        6012  +
pub enum TestBodyStructureError {
 6163   6013   
    #[allow(missing_docs)] // documentation missing in model
 6164   6014   
    InternalServerError(crate::error::InternalServerError),
 6165   6015   
}
 6166         -
impl ::std::fmt::Display for HttpRequestWithFloatLabelsError {
        6016  +
impl ::std::fmt::Display for TestBodyStructureError {
 6167   6017   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6168   6018   
        match &self {
 6169         -
            HttpRequestWithFloatLabelsError::ValidationException(_inner) => _inner.fmt(f),
 6170         -
            HttpRequestWithFloatLabelsError::InternalServerError(_inner) => _inner.fmt(f),
        6019  +
            TestBodyStructureError::InternalServerError(_inner) => _inner.fmt(f),
 6171   6020   
        }
 6172   6021   
    }
 6173   6022   
}
 6174         -
impl HttpRequestWithFloatLabelsError {
 6175         -
    /// Returns `true` if the error kind is `HttpRequestWithFloatLabelsError::ValidationException`.
 6176         -
    pub fn is_validation_exception(&self) -> bool {
 6177         -
        matches!(
 6178         -
            &self,
 6179         -
            HttpRequestWithFloatLabelsError::ValidationException(_)
 6180         -
        )
 6181         -
    }
 6182         -
    /// Returns `true` if the error kind is `HttpRequestWithFloatLabelsError::InternalServerError`.
        6023  +
impl TestBodyStructureError {
        6024  +
    /// Returns `true` if the error kind is `TestBodyStructureError::InternalServerError`.
 6183   6025   
    pub fn is_internal_server_error(&self) -> bool {
 6184         -
        matches!(
 6185         -
            &self,
 6186         -
            HttpRequestWithFloatLabelsError::InternalServerError(_)
 6187         -
        )
        6026  +
        matches!(&self, TestBodyStructureError::InternalServerError(_))
 6188   6027   
    }
 6189   6028   
    /// Returns the error name string by matching the correct variant.
 6190   6029   
    pub fn name(&self) -> &'static str {
 6191   6030   
        match &self {
 6192         -
            HttpRequestWithFloatLabelsError::ValidationException(_inner) => _inner.name(),
 6193         -
            HttpRequestWithFloatLabelsError::InternalServerError(_inner) => _inner.name(),
        6031  +
            TestBodyStructureError::InternalServerError(_inner) => _inner.name(),
 6194   6032   
        }
 6195   6033   
    }
 6196   6034   
}
 6197         -
impl ::std::error::Error for HttpRequestWithFloatLabelsError {
        6035  +
impl ::std::error::Error for TestBodyStructureError {
 6198   6036   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6199   6037   
        match &self {
 6200         -
            HttpRequestWithFloatLabelsError::ValidationException(_inner) => Some(_inner),
 6201         -
            HttpRequestWithFloatLabelsError::InternalServerError(_inner) => Some(_inner),
        6038  +
            TestBodyStructureError::InternalServerError(_inner) => Some(_inner),
 6202   6039   
        }
 6203   6040   
    }
 6204   6041   
}
 6205         -
impl ::std::convert::From<crate::error::ValidationException>
 6206         -
    for crate::error::HttpRequestWithFloatLabelsError
        6042  +
impl ::std::convert::From<crate::error::InternalServerError>
        6043  +
    for crate::error::TestBodyStructureError
 6207   6044   
{
 6208         -
    fn from(
 6209         -
        variant: crate::error::ValidationException,
 6210         -
    ) -> crate::error::HttpRequestWithFloatLabelsError {
 6211         -
        Self::ValidationException(variant)
 6212         -
    }
 6213         -
}
 6214         -
impl ::std::convert::From<crate::error::InternalServerError>
 6215         -
    for crate::error::HttpRequestWithFloatLabelsError
 6216         -
{
 6217         -
    fn from(
 6218         -
        variant: crate::error::InternalServerError,
 6219         -
    ) -> crate::error::HttpRequestWithFloatLabelsError {
        6045  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestBodyStructureError {
 6220   6046   
        Self::InternalServerError(variant)
 6221   6047   
    }
 6222   6048   
}
 6223   6049   
 6224         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithFloatLabelsError {
 6225         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithFloatLabelsError {
        6050  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestBodyStructureError {
        6051  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestBodyStructureError {
 6226   6052   
        ::pyo3::Python::with_gil(|py| {
 6227   6053   
            let error = variant.value(py);
 6228         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 6229         -
                return error.into();
 6230         -
            }
        6054  +
 6231   6055   
            crate::error::InternalServerError {
 6232   6056   
                message: error.to_string(),
 6233   6057   
            }
 6234   6058   
            .into()
 6235   6059   
        })
 6236   6060   
    }
 6237   6061   
}
 6238   6062   
 6239         -
/// Error type for the `HttpRequestWithGreedyLabelInPath` operation.
 6240         -
/// Each variant represents an error that can occur for the `HttpRequestWithGreedyLabelInPath` operation.
        6063  +
/// Error type for the `TestPayloadStructure` operation.
        6064  +
/// Each variant represents an error that can occur for the `TestPayloadStructure` operation.
 6241   6065   
#[derive(::std::fmt::Debug)]
 6242         -
pub enum HttpRequestWithGreedyLabelInPathError {
 6243         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 6244         -
    ValidationException(crate::error::ValidationException),
        6066  +
pub enum TestPayloadStructureError {
 6245   6067   
    #[allow(missing_docs)] // documentation missing in model
 6246   6068   
    InternalServerError(crate::error::InternalServerError),
 6247   6069   
}
 6248         -
impl ::std::fmt::Display for HttpRequestWithGreedyLabelInPathError {
        6070  +
impl ::std::fmt::Display for TestPayloadStructureError {
 6249   6071   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6250   6072   
        match &self {
 6251         -
            HttpRequestWithGreedyLabelInPathError::ValidationException(_inner) => _inner.fmt(f),
 6252         -
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_inner) => _inner.fmt(f),
        6073  +
            TestPayloadStructureError::InternalServerError(_inner) => _inner.fmt(f),
 6253   6074   
        }
 6254   6075   
    }
 6255   6076   
}
 6256         -
impl HttpRequestWithGreedyLabelInPathError {
 6257         -
    /// Returns `true` if the error kind is `HttpRequestWithGreedyLabelInPathError::ValidationException`.
 6258         -
    pub fn is_validation_exception(&self) -> bool {
 6259         -
        matches!(
 6260         -
            &self,
 6261         -
            HttpRequestWithGreedyLabelInPathError::ValidationException(_)
 6262         -
        )
 6263         -
    }
 6264         -
    /// Returns `true` if the error kind is `HttpRequestWithGreedyLabelInPathError::InternalServerError`.
        6077  +
impl TestPayloadStructureError {
        6078  +
    /// Returns `true` if the error kind is `TestPayloadStructureError::InternalServerError`.
 6265   6079   
    pub fn is_internal_server_error(&self) -> bool {
 6266         -
        matches!(
 6267         -
            &self,
 6268         -
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_)
 6269         -
        )
        6080  +
        matches!(&self, TestPayloadStructureError::InternalServerError(_))
 6270   6081   
    }
 6271   6082   
    /// Returns the error name string by matching the correct variant.
 6272   6083   
    pub fn name(&self) -> &'static str {
 6273   6084   
        match &self {
 6274         -
            HttpRequestWithGreedyLabelInPathError::ValidationException(_inner) => _inner.name(),
 6275         -
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_inner) => _inner.name(),
        6085  +
            TestPayloadStructureError::InternalServerError(_inner) => _inner.name(),
 6276   6086   
        }
 6277   6087   
    }
 6278   6088   
}
 6279         -
impl ::std::error::Error for HttpRequestWithGreedyLabelInPathError {
        6089  +
impl ::std::error::Error for TestPayloadStructureError {
 6280   6090   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6281   6091   
        match &self {
 6282         -
            HttpRequestWithGreedyLabelInPathError::ValidationException(_inner) => Some(_inner),
 6283         -
            HttpRequestWithGreedyLabelInPathError::InternalServerError(_inner) => Some(_inner),
        6092  +
            TestPayloadStructureError::InternalServerError(_inner) => Some(_inner),
 6284   6093   
        }
 6285   6094   
    }
 6286   6095   
}
 6287         -
impl ::std::convert::From<crate::error::ValidationException>
 6288         -
    for crate::error::HttpRequestWithGreedyLabelInPathError
 6289         -
{
 6290         -
    fn from(
 6291         -
        variant: crate::error::ValidationException,
 6292         -
    ) -> crate::error::HttpRequestWithGreedyLabelInPathError {
 6293         -
        Self::ValidationException(variant)
 6294         -
    }
 6295         -
}
 6296   6096   
impl ::std::convert::From<crate::error::InternalServerError>
 6297         -
    for crate::error::HttpRequestWithGreedyLabelInPathError
        6097  +
    for crate::error::TestPayloadStructureError
 6298   6098   
{
 6299         -
    fn from(
 6300         -
        variant: crate::error::InternalServerError,
 6301         -
    ) -> crate::error::HttpRequestWithGreedyLabelInPathError {
        6099  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestPayloadStructureError {
 6302   6100   
        Self::InternalServerError(variant)
 6303   6101   
    }
 6304   6102   
}
 6305   6103   
 6306         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithGreedyLabelInPathError {
 6307         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithGreedyLabelInPathError {
        6104  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPayloadStructureError {
        6105  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPayloadStructureError {
 6308   6106   
        ::pyo3::Python::with_gil(|py| {
 6309   6107   
            let error = variant.value(py);
 6310         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 6311         -
                return error.into();
 6312         -
            }
        6108  +
 6313   6109   
            crate::error::InternalServerError {
 6314   6110   
                message: error.to_string(),
 6315   6111   
            }
 6316   6112   
            .into()
 6317   6113   
        })
 6318   6114   
    }
 6319   6115   
}
 6320   6116   
 6321         -
/// Error type for the `HttpRequestWithLabelsAndTimestampFormat` operation.
 6322         -
/// Each variant represents an error that can occur for the `HttpRequestWithLabelsAndTimestampFormat` operation.
        6117  +
/// Error type for the `TestPayloadBlob` operation.
        6118  +
/// Each variant represents an error that can occur for the `TestPayloadBlob` operation.
 6323   6119   
#[derive(::std::fmt::Debug)]
 6324         -
pub enum HttpRequestWithLabelsAndTimestampFormatError {
 6325         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 6326         -
    ValidationException(crate::error::ValidationException),
        6120  +
pub enum TestPayloadBlobError {
 6327   6121   
    #[allow(missing_docs)] // documentation missing in model
 6328   6122   
    InternalServerError(crate::error::InternalServerError),
 6329   6123   
}
 6330         -
impl ::std::fmt::Display for HttpRequestWithLabelsAndTimestampFormatError {
        6124  +
impl ::std::fmt::Display for TestPayloadBlobError {
 6331   6125   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6332   6126   
        match &self {
 6333         -
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_inner) => {
 6334         -
                _inner.fmt(f)
 6335         -
            }
 6336         -
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_inner) => {
 6337         -
                _inner.fmt(f)
 6338         -
            }
        6127  +
            TestPayloadBlobError::InternalServerError(_inner) => _inner.fmt(f),
 6339   6128   
        }
 6340   6129   
    }
 6341   6130   
}
 6342         -
impl HttpRequestWithLabelsAndTimestampFormatError {
 6343         -
    /// Returns `true` if the error kind is `HttpRequestWithLabelsAndTimestampFormatError::ValidationException`.
 6344         -
    pub fn is_validation_exception(&self) -> bool {
 6345         -
        matches!(
 6346         -
            &self,
 6347         -
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_)
 6348         -
        )
 6349         -
    }
 6350         -
    /// Returns `true` if the error kind is `HttpRequestWithLabelsAndTimestampFormatError::InternalServerError`.
        6131  +
impl TestPayloadBlobError {
        6132  +
    /// Returns `true` if the error kind is `TestPayloadBlobError::InternalServerError`.
 6351   6133   
    pub fn is_internal_server_error(&self) -> bool {
 6352         -
        matches!(
 6353         -
            &self,
 6354         -
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_)
 6355         -
        )
        6134  +
        matches!(&self, TestPayloadBlobError::InternalServerError(_))
 6356   6135   
    }
 6357   6136   
    /// Returns the error name string by matching the correct variant.
 6358   6137   
    pub fn name(&self) -> &'static str {
 6359   6138   
        match &self {
 6360         -
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_inner) => {
 6361         -
                _inner.name()
 6362         -
            }
 6363         -
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_inner) => {
 6364         -
                _inner.name()
 6365         -
            }
        6139  +
            TestPayloadBlobError::InternalServerError(_inner) => _inner.name(),
 6366   6140   
        }
 6367   6141   
    }
 6368   6142   
}
 6369         -
impl ::std::error::Error for HttpRequestWithLabelsAndTimestampFormatError {
        6143  +
impl ::std::error::Error for TestPayloadBlobError {
 6370   6144   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6371   6145   
        match &self {
 6372         -
            HttpRequestWithLabelsAndTimestampFormatError::ValidationException(_inner) => {
 6373         -
                Some(_inner)
 6374         -
            }
 6375         -
            HttpRequestWithLabelsAndTimestampFormatError::InternalServerError(_inner) => {
 6376         -
                Some(_inner)
 6377         -
            }
        6146  +
            TestPayloadBlobError::InternalServerError(_inner) => Some(_inner),
 6378   6147   
        }
 6379   6148   
    }
 6380   6149   
}
 6381         -
impl ::std::convert::From<crate::error::ValidationException>
 6382         -
    for crate::error::HttpRequestWithLabelsAndTimestampFormatError
 6383         -
{
 6384         -
    fn from(
 6385         -
        variant: crate::error::ValidationException,
 6386         -
    ) -> crate::error::HttpRequestWithLabelsAndTimestampFormatError {
 6387         -
        Self::ValidationException(variant)
 6388         -
    }
 6389         -
}
 6390   6150   
impl ::std::convert::From<crate::error::InternalServerError>
 6391         -
    for crate::error::HttpRequestWithLabelsAndTimestampFormatError
        6151  +
    for crate::error::TestPayloadBlobError
 6392   6152   
{
 6393         -
    fn from(
 6394         -
        variant: crate::error::InternalServerError,
 6395         -
    ) -> crate::error::HttpRequestWithLabelsAndTimestampFormatError {
        6153  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestPayloadBlobError {
 6396   6154   
        Self::InternalServerError(variant)
 6397   6155   
    }
 6398   6156   
}
 6399   6157   
 6400         -
impl ::std::convert::From<::pyo3::PyErr>
 6401         -
    for crate::error::HttpRequestWithLabelsAndTimestampFormatError
 6402         -
{
 6403         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithLabelsAndTimestampFormatError {
        6158  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPayloadBlobError {
        6159  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPayloadBlobError {
 6404   6160   
        ::pyo3::Python::with_gil(|py| {
 6405   6161   
            let error = variant.value(py);
 6406         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 6407         -
                return error.into();
 6408         -
            }
        6162  +
 6409   6163   
            crate::error::InternalServerError {
 6410   6164   
                message: error.to_string(),
 6411   6165   
            }
 6412   6166   
            .into()
 6413   6167   
        })
 6414   6168   
    }
 6415   6169   
}
 6416   6170   
 6417         -
/// Error type for the `HttpRequestWithLabels` operation.
 6418         -
/// Each variant represents an error that can occur for the `HttpRequestWithLabels` operation.
        6171  +
/// Error type for the `TestGetNoPayload` operation.
        6172  +
/// Each variant represents an error that can occur for the `TestGetNoPayload` operation.
 6419   6173   
#[derive(::std::fmt::Debug)]
 6420         -
pub enum HttpRequestWithLabelsError {
 6421         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 6422         -
    ValidationException(crate::error::ValidationException),
        6174  +
pub enum TestGetNoPayloadError {
 6423   6175   
    #[allow(missing_docs)] // documentation missing in model
 6424   6176   
    InternalServerError(crate::error::InternalServerError),
 6425   6177   
}
 6426         -
impl ::std::fmt::Display for HttpRequestWithLabelsError {
        6178  +
impl ::std::fmt::Display for TestGetNoPayloadError {
 6427   6179   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6428   6180   
        match &self {
 6429         -
            HttpRequestWithLabelsError::ValidationException(_inner) => _inner.fmt(f),
 6430         -
            HttpRequestWithLabelsError::InternalServerError(_inner) => _inner.fmt(f),
        6181  +
            TestGetNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 6431   6182   
        }
 6432   6183   
    }
 6433   6184   
}
 6434         -
impl HttpRequestWithLabelsError {
 6435         -
    /// Returns `true` if the error kind is `HttpRequestWithLabelsError::ValidationException`.
 6436         -
    pub fn is_validation_exception(&self) -> bool {
 6437         -
        matches!(&self, HttpRequestWithLabelsError::ValidationException(_))
 6438         -
    }
 6439         -
    /// Returns `true` if the error kind is `HttpRequestWithLabelsError::InternalServerError`.
        6185  +
impl TestGetNoPayloadError {
        6186  +
    /// Returns `true` if the error kind is `TestGetNoPayloadError::InternalServerError`.
 6440   6187   
    pub fn is_internal_server_error(&self) -> bool {
 6441         -
        matches!(&self, HttpRequestWithLabelsError::InternalServerError(_))
        6188  +
        matches!(&self, TestGetNoPayloadError::InternalServerError(_))
 6442   6189   
    }
 6443   6190   
    /// Returns the error name string by matching the correct variant.
 6444   6191   
    pub fn name(&self) -> &'static str {
 6445   6192   
        match &self {
 6446         -
            HttpRequestWithLabelsError::ValidationException(_inner) => _inner.name(),
 6447         -
            HttpRequestWithLabelsError::InternalServerError(_inner) => _inner.name(),
        6193  +
            TestGetNoPayloadError::InternalServerError(_inner) => _inner.name(),
 6448   6194   
        }
 6449   6195   
    }
 6450   6196   
}
 6451         -
impl ::std::error::Error for HttpRequestWithLabelsError {
        6197  +
impl ::std::error::Error for TestGetNoPayloadError {
 6452   6198   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6453   6199   
        match &self {
 6454         -
            HttpRequestWithLabelsError::ValidationException(_inner) => Some(_inner),
 6455         -
            HttpRequestWithLabelsError::InternalServerError(_inner) => Some(_inner),
        6200  +
            TestGetNoPayloadError::InternalServerError(_inner) => Some(_inner),
 6456   6201   
        }
 6457   6202   
    }
 6458   6203   
}
 6459         -
impl ::std::convert::From<crate::error::ValidationException>
 6460         -
    for crate::error::HttpRequestWithLabelsError
 6461         -
{
 6462         -
    fn from(
 6463         -
        variant: crate::error::ValidationException,
 6464         -
    ) -> crate::error::HttpRequestWithLabelsError {
 6465         -
        Self::ValidationException(variant)
 6466         -
    }
 6467         -
}
 6468   6204   
impl ::std::convert::From<crate::error::InternalServerError>
 6469         -
    for crate::error::HttpRequestWithLabelsError
        6205  +
    for crate::error::TestGetNoPayloadError
 6470   6206   
{
 6471         -
    fn from(
 6472         -
        variant: crate::error::InternalServerError,
 6473         -
    ) -> crate::error::HttpRequestWithLabelsError {
        6207  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestGetNoPayloadError {
 6474   6208   
        Self::InternalServerError(variant)
 6475   6209   
    }
 6476   6210   
}
 6477   6211   
 6478         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpRequestWithLabelsError {
 6479         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::HttpRequestWithLabelsError {
        6212  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestGetNoPayloadError {
        6213  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestGetNoPayloadError {
 6480   6214   
        ::pyo3::Python::with_gil(|py| {
 6481   6215   
            let error = variant.value(py);
 6482         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 6483         -
                return error.into();
 6484         -
            }
        6216  +
 6485   6217   
            crate::error::InternalServerError {
 6486   6218   
                message: error.to_string(),
 6487   6219   
            }
 6488   6220   
            .into()
 6489   6221   
        })
 6490   6222   
    }
 6491   6223   
}
 6492   6224   
 6493         -
/// Error type for the `MediaTypeHeader` operation.
 6494         -
/// Each variant represents an error that can occur for the `MediaTypeHeader` operation.
        6225  +
/// Error type for the `TestPostNoPayload` operation.
        6226  +
/// Each variant represents an error that can occur for the `TestPostNoPayload` operation.
 6495   6227   
#[derive(::std::fmt::Debug)]
 6496         -
pub enum MediaTypeHeaderError {
        6228  +
pub enum TestPostNoPayloadError {
 6497   6229   
    #[allow(missing_docs)] // documentation missing in model
 6498   6230   
    InternalServerError(crate::error::InternalServerError),
 6499   6231   
}
 6500         -
impl ::std::fmt::Display for MediaTypeHeaderError {
        6232  +
impl ::std::fmt::Display for TestPostNoPayloadError {
 6501   6233   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6502   6234   
        match &self {
 6503         -
            MediaTypeHeaderError::InternalServerError(_inner) => _inner.fmt(f),
        6235  +
            TestPostNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 6504   6236   
        }
 6505   6237   
    }
 6506   6238   
}
 6507         -
impl MediaTypeHeaderError {
 6508         -
    /// Returns `true` if the error kind is `MediaTypeHeaderError::InternalServerError`.
        6239  +
impl TestPostNoPayloadError {
        6240  +
    /// Returns `true` if the error kind is `TestPostNoPayloadError::InternalServerError`.
 6509   6241   
    pub fn is_internal_server_error(&self) -> bool {
 6510         -
        matches!(&self, MediaTypeHeaderError::InternalServerError(_))
        6242  +
        matches!(&self, TestPostNoPayloadError::InternalServerError(_))
 6511   6243   
    }
 6512   6244   
    /// Returns the error name string by matching the correct variant.
 6513   6245   
    pub fn name(&self) -> &'static str {
 6514   6246   
        match &self {
 6515         -
            MediaTypeHeaderError::InternalServerError(_inner) => _inner.name(),
        6247  +
            TestPostNoPayloadError::InternalServerError(_inner) => _inner.name(),
 6516   6248   
        }
 6517   6249   
    }
 6518   6250   
}
 6519         -
impl ::std::error::Error for MediaTypeHeaderError {
        6251  +
impl ::std::error::Error for TestPostNoPayloadError {
 6520   6252   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6521   6253   
        match &self {
 6522         -
            MediaTypeHeaderError::InternalServerError(_inner) => Some(_inner),
        6254  +
            TestPostNoPayloadError::InternalServerError(_inner) => Some(_inner),
 6523   6255   
        }
 6524   6256   
    }
 6525   6257   
}
 6526   6258   
impl ::std::convert::From<crate::error::InternalServerError>
 6527         -
    for crate::error::MediaTypeHeaderError
        6259  +
    for crate::error::TestPostNoPayloadError
 6528   6260   
{
 6529         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::MediaTypeHeaderError {
        6261  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::TestPostNoPayloadError {
 6530   6262   
        Self::InternalServerError(variant)
 6531   6263   
    }
 6532   6264   
}
 6533   6265   
 6534         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::MediaTypeHeaderError {
 6535         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::MediaTypeHeaderError {
        6266  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPostNoPayloadError {
        6267  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPostNoPayloadError {
 6536   6268   
        ::pyo3::Python::with_gil(|py| {
 6537   6269   
            let error = variant.value(py);
 6538   6270   
 6539   6271   
            crate::error::InternalServerError {
 6540   6272   
                message: error.to_string(),
 6541   6273   
            }
 6542   6274   
            .into()
 6543   6275   
        })
 6544   6276   
    }
 6545   6277   
}
 6546   6278   
 6547         -
/// Error type for the `TimestampFormatHeaders` operation.
 6548         -
/// Each variant represents an error that can occur for the `TimestampFormatHeaders` operation.
        6279  +
/// Error type for the `TestGetNoInputNoPayload` operation.
        6280  +
/// Each variant represents an error that can occur for the `TestGetNoInputNoPayload` operation.
 6549   6281   
#[derive(::std::fmt::Debug)]
 6550         -
pub enum TimestampFormatHeadersError {
        6282  +
pub enum TestGetNoInputNoPayloadError {
 6551   6283   
    #[allow(missing_docs)] // documentation missing in model
 6552   6284   
    InternalServerError(crate::error::InternalServerError),
 6553   6285   
}
 6554         -
impl ::std::fmt::Display for TimestampFormatHeadersError {
        6286  +
impl ::std::fmt::Display for TestGetNoInputNoPayloadError {
 6555   6287   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6556   6288   
        match &self {
 6557         -
            TimestampFormatHeadersError::InternalServerError(_inner) => _inner.fmt(f),
        6289  +
            TestGetNoInputNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 6558   6290   
        }
 6559   6291   
    }
 6560   6292   
}
 6561         -
impl TimestampFormatHeadersError {
 6562         -
    /// Returns `true` if the error kind is `TimestampFormatHeadersError::InternalServerError`.
        6293  +
impl TestGetNoInputNoPayloadError {
        6294  +
    /// Returns `true` if the error kind is `TestGetNoInputNoPayloadError::InternalServerError`.
 6563   6295   
    pub fn is_internal_server_error(&self) -> bool {
 6564         -
        matches!(&self, TimestampFormatHeadersError::InternalServerError(_))
        6296  +
        matches!(&self, TestGetNoInputNoPayloadError::InternalServerError(_))
 6565   6297   
    }
 6566   6298   
    /// Returns the error name string by matching the correct variant.
 6567   6299   
    pub fn name(&self) -> &'static str {
 6568   6300   
        match &self {
 6569         -
            TimestampFormatHeadersError::InternalServerError(_inner) => _inner.name(),
        6301  +
            TestGetNoInputNoPayloadError::InternalServerError(_inner) => _inner.name(),
 6570   6302   
        }
 6571   6303   
    }
 6572   6304   
}
 6573         -
impl ::std::error::Error for TimestampFormatHeadersError {
        6305  +
impl ::std::error::Error for TestGetNoInputNoPayloadError {
 6574   6306   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6575   6307   
        match &self {
 6576         -
            TimestampFormatHeadersError::InternalServerError(_inner) => Some(_inner),
        6308  +
            TestGetNoInputNoPayloadError::InternalServerError(_inner) => Some(_inner),
 6577   6309   
        }
 6578   6310   
    }
 6579   6311   
}
 6580   6312   
impl ::std::convert::From<crate::error::InternalServerError>
 6581         -
    for crate::error::TimestampFormatHeadersError
        6313  +
    for crate::error::TestGetNoInputNoPayloadError
 6582   6314   
{
 6583   6315   
    fn from(
 6584   6316   
        variant: crate::error::InternalServerError,
 6585         -
    ) -> crate::error::TimestampFormatHeadersError {
        6317  +
    ) -> crate::error::TestGetNoInputNoPayloadError {
 6586   6318   
        Self::InternalServerError(variant)
 6587   6319   
    }
 6588   6320   
}
 6589   6321   
 6590         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TimestampFormatHeadersError {
 6591         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::TimestampFormatHeadersError {
        6322  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestGetNoInputNoPayloadError {
        6323  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestGetNoInputNoPayloadError {
 6592   6324   
        ::pyo3::Python::with_gil(|py| {
 6593   6325   
            let error = variant.value(py);
 6594   6326   
 6595   6327   
            crate::error::InternalServerError {
 6596   6328   
                message: error.to_string(),
 6597   6329   
            }
 6598   6330   
            .into()
 6599   6331   
        })
 6600   6332   
    }
 6601   6333   
}
 6602   6334   
 6603         -
/// Error type for the `NullAndEmptyHeadersServer` operation.
 6604         -
/// Each variant represents an error that can occur for the `NullAndEmptyHeadersServer` operation.
        6335  +
/// Error type for the `TestPostNoInputNoPayload` operation.
        6336  +
/// Each variant represents an error that can occur for the `TestPostNoInputNoPayload` operation.
 6605   6337   
#[derive(::std::fmt::Debug)]
 6606         -
pub enum NullAndEmptyHeadersServerError {
        6338  +
pub enum TestPostNoInputNoPayloadError {
 6607   6339   
    #[allow(missing_docs)] // documentation missing in model
 6608   6340   
    InternalServerError(crate::error::InternalServerError),
 6609   6341   
}
 6610         -
impl ::std::fmt::Display for NullAndEmptyHeadersServerError {
        6342  +
impl ::std::fmt::Display for TestPostNoInputNoPayloadError {
 6611   6343   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6612   6344   
        match &self {
 6613         -
            NullAndEmptyHeadersServerError::InternalServerError(_inner) => _inner.fmt(f),
        6345  +
            TestPostNoInputNoPayloadError::InternalServerError(_inner) => _inner.fmt(f),
 6614   6346   
        }
 6615   6347   
    }
 6616   6348   
}
 6617         -
impl NullAndEmptyHeadersServerError {
 6618         -
    /// Returns `true` if the error kind is `NullAndEmptyHeadersServerError::InternalServerError`.
        6349  +
impl TestPostNoInputNoPayloadError {
        6350  +
    /// Returns `true` if the error kind is `TestPostNoInputNoPayloadError::InternalServerError`.
 6619   6351   
    pub fn is_internal_server_error(&self) -> bool {
 6620         -
        matches!(
 6621         -
            &self,
 6622         -
            NullAndEmptyHeadersServerError::InternalServerError(_)
 6623         -
        )
        6352  +
        matches!(&self, TestPostNoInputNoPayloadError::InternalServerError(_))
 6624   6353   
    }
 6625   6354   
    /// Returns the error name string by matching the correct variant.
 6626   6355   
    pub fn name(&self) -> &'static str {
 6627   6356   
        match &self {
 6628         -
            NullAndEmptyHeadersServerError::InternalServerError(_inner) => _inner.name(),
        6357  +
            TestPostNoInputNoPayloadError::InternalServerError(_inner) => _inner.name(),
 6629   6358   
        }
 6630   6359   
    }
 6631   6360   
}
 6632         -
impl ::std::error::Error for NullAndEmptyHeadersServerError {
        6361  +
impl ::std::error::Error for TestPostNoInputNoPayloadError {
 6633   6362   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6634   6363   
        match &self {
 6635         -
            NullAndEmptyHeadersServerError::InternalServerError(_inner) => Some(_inner),
        6364  +
            TestPostNoInputNoPayloadError::InternalServerError(_inner) => Some(_inner),
 6636   6365   
        }
 6637   6366   
    }
 6638   6367   
}
 6639   6368   
impl ::std::convert::From<crate::error::InternalServerError>
 6640         -
    for crate::error::NullAndEmptyHeadersServerError
        6369  +
    for crate::error::TestPostNoInputNoPayloadError
 6641   6370   
{
 6642   6371   
    fn from(
 6643   6372   
        variant: crate::error::InternalServerError,
 6644         -
    ) -> crate::error::NullAndEmptyHeadersServerError {
        6373  +
    ) -> crate::error::TestPostNoInputNoPayloadError {
 6645   6374   
        Self::InternalServerError(variant)
 6646   6375   
    }
 6647   6376   
}
 6648   6377   
 6649         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NullAndEmptyHeadersServerError {
 6650         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::NullAndEmptyHeadersServerError {
        6378  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::TestPostNoInputNoPayloadError {
        6379  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::TestPostNoInputNoPayloadError {
 6651   6380   
        ::pyo3::Python::with_gil(|py| {
 6652   6381   
            let error = variant.value(py);
 6653   6382   
 6654   6383   
            crate::error::InternalServerError {
 6655   6384   
                message: error.to_string(),
 6656   6385   
            }
 6657   6386   
            .into()
 6658   6387   
        })
 6659   6388   
    }
 6660   6389   
}
 6661   6390   
 6662         -
/// Error type for the `NullAndEmptyHeadersClient` operation.
 6663         -
/// Each variant represents an error that can occur for the `NullAndEmptyHeadersClient` operation.
        6391  +
/// Error type for the `DatetimeOffsets` operation.
        6392  +
/// Each variant represents an error that can occur for the `DatetimeOffsets` operation.
 6664   6393   
#[derive(::std::fmt::Debug)]
 6665         -
pub enum NullAndEmptyHeadersClientError {
        6394  +
pub enum DatetimeOffsetsError {
 6666   6395   
    #[allow(missing_docs)] // documentation missing in model
 6667   6396   
    InternalServerError(crate::error::InternalServerError),
 6668   6397   
}
 6669         -
impl ::std::fmt::Display for NullAndEmptyHeadersClientError {
        6398  +
impl ::std::fmt::Display for DatetimeOffsetsError {
 6670   6399   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6671   6400   
        match &self {
 6672         -
            NullAndEmptyHeadersClientError::InternalServerError(_inner) => _inner.fmt(f),
        6401  +
            DatetimeOffsetsError::InternalServerError(_inner) => _inner.fmt(f),
 6673   6402   
        }
 6674   6403   
    }
 6675   6404   
}
 6676         -
impl NullAndEmptyHeadersClientError {
 6677         -
    /// Returns `true` if the error kind is `NullAndEmptyHeadersClientError::InternalServerError`.
        6405  +
impl DatetimeOffsetsError {
        6406  +
    /// Returns `true` if the error kind is `DatetimeOffsetsError::InternalServerError`.
 6678   6407   
    pub fn is_internal_server_error(&self) -> bool {
 6679         -
        matches!(
 6680         -
            &self,
 6681         -
            NullAndEmptyHeadersClientError::InternalServerError(_)
 6682         -
        )
        6408  +
        matches!(&self, DatetimeOffsetsError::InternalServerError(_))
 6683   6409   
    }
 6684   6410   
    /// Returns the error name string by matching the correct variant.
 6685   6411   
    pub fn name(&self) -> &'static str {
 6686   6412   
        match &self {
 6687         -
            NullAndEmptyHeadersClientError::InternalServerError(_inner) => _inner.name(),
        6413  +
            DatetimeOffsetsError::InternalServerError(_inner) => _inner.name(),
 6688   6414   
        }
 6689   6415   
    }
 6690   6416   
}
 6691         -
impl ::std::error::Error for NullAndEmptyHeadersClientError {
        6417  +
impl ::std::error::Error for DatetimeOffsetsError {
 6692   6418   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6693   6419   
        match &self {
 6694         -
            NullAndEmptyHeadersClientError::InternalServerError(_inner) => Some(_inner),
        6420  +
            DatetimeOffsetsError::InternalServerError(_inner) => Some(_inner),
 6695   6421   
        }
 6696   6422   
    }
 6697   6423   
}
 6698   6424   
impl ::std::convert::From<crate::error::InternalServerError>
 6699         -
    for crate::error::NullAndEmptyHeadersClientError
        6425  +
    for crate::error::DatetimeOffsetsError
 6700   6426   
{
 6701         -
    fn from(
 6702         -
        variant: crate::error::InternalServerError,
 6703         -
    ) -> crate::error::NullAndEmptyHeadersClientError {
        6427  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::DatetimeOffsetsError {
 6704   6428   
        Self::InternalServerError(variant)
 6705   6429   
    }
 6706   6430   
}
 6707   6431   
 6708         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NullAndEmptyHeadersClientError {
 6709         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::NullAndEmptyHeadersClientError {
        6432  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DatetimeOffsetsError {
        6433  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::DatetimeOffsetsError {
 6710   6434   
        ::pyo3::Python::with_gil(|py| {
 6711   6435   
            let error = variant.value(py);
 6712   6436   
 6713   6437   
            crate::error::InternalServerError {
 6714   6438   
                message: error.to_string(),
 6715   6439   
            }
 6716   6440   
            .into()
 6717   6441   
        })
 6718   6442   
    }
 6719   6443   
}
 6720   6444   
 6721         -
/// Error type for the `InputAndOutputWithHeaders` operation.
 6722         -
/// Each variant represents an error that can occur for the `InputAndOutputWithHeaders` operation.
        6445  +
/// Error type for the `FractionalSeconds` operation.
        6446  +
/// Each variant represents an error that can occur for the `FractionalSeconds` operation.
 6723   6447   
#[derive(::std::fmt::Debug)]
 6724         -
pub enum InputAndOutputWithHeadersError {
 6725         -
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 6726         -
    ValidationException(crate::error::ValidationException),
        6448  +
pub enum FractionalSecondsError {
 6727   6449   
    #[allow(missing_docs)] // documentation missing in model
 6728   6450   
    InternalServerError(crate::error::InternalServerError),
 6729   6451   
}
 6730         -
impl ::std::fmt::Display for InputAndOutputWithHeadersError {
        6452  +
impl ::std::fmt::Display for FractionalSecondsError {
 6731   6453   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6732   6454   
        match &self {
 6733         -
            InputAndOutputWithHeadersError::ValidationException(_inner) => _inner.fmt(f),
 6734         -
            InputAndOutputWithHeadersError::InternalServerError(_inner) => _inner.fmt(f),
        6455  +
            FractionalSecondsError::InternalServerError(_inner) => _inner.fmt(f),
 6735   6456   
        }
 6736   6457   
    }
 6737   6458   
}
 6738         -
impl InputAndOutputWithHeadersError {
 6739         -
    /// Returns `true` if the error kind is `InputAndOutputWithHeadersError::ValidationException`.
 6740         -
    pub fn is_validation_exception(&self) -> bool {
 6741         -
        matches!(
 6742         -
            &self,
 6743         -
            InputAndOutputWithHeadersError::ValidationException(_)
 6744         -
        )
 6745         -
    }
 6746         -
    /// Returns `true` if the error kind is `InputAndOutputWithHeadersError::InternalServerError`.
        6459  +
impl FractionalSecondsError {
        6460  +
    /// Returns `true` if the error kind is `FractionalSecondsError::InternalServerError`.
 6747   6461   
    pub fn is_internal_server_error(&self) -> bool {
 6748         -
        matches!(
 6749         -
            &self,
 6750         -
            InputAndOutputWithHeadersError::InternalServerError(_)
 6751         -
        )
        6462  +
        matches!(&self, FractionalSecondsError::InternalServerError(_))
 6752   6463   
    }
 6753   6464   
    /// Returns the error name string by matching the correct variant.
 6754   6465   
    pub fn name(&self) -> &'static str {
 6755   6466   
        match &self {
 6756         -
            InputAndOutputWithHeadersError::ValidationException(_inner) => _inner.name(),
 6757         -
            InputAndOutputWithHeadersError::InternalServerError(_inner) => _inner.name(),
        6467  +
            FractionalSecondsError::InternalServerError(_inner) => _inner.name(),
 6758   6468   
        }
 6759   6469   
    }
 6760   6470   
}
 6761         -
impl ::std::error::Error for InputAndOutputWithHeadersError {
        6471  +
impl ::std::error::Error for FractionalSecondsError {
 6762   6472   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6763   6473   
        match &self {
 6764         -
            InputAndOutputWithHeadersError::ValidationException(_inner) => Some(_inner),
 6765         -
            InputAndOutputWithHeadersError::InternalServerError(_inner) => Some(_inner),
        6474  +
            FractionalSecondsError::InternalServerError(_inner) => Some(_inner),
 6766   6475   
        }
 6767   6476   
    }
 6768   6477   
}
 6769         -
impl ::std::convert::From<crate::error::ValidationException>
 6770         -
    for crate::error::InputAndOutputWithHeadersError
        6478  +
impl ::std::convert::From<crate::error::InternalServerError>
        6479  +
    for crate::error::FractionalSecondsError
 6771   6480   
{
 6772         -
    fn from(
 6773         -
        variant: crate::error::ValidationException,
 6774         -
    ) -> crate::error::InputAndOutputWithHeadersError {
 6775         -
        Self::ValidationException(variant)
        6481  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::FractionalSecondsError {
        6482  +
        Self::InternalServerError(variant)
        6483  +
    }
        6484  +
}
        6485  +
        6486  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::FractionalSecondsError {
        6487  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::FractionalSecondsError {
        6488  +
        ::pyo3::Python::with_gil(|py| {
        6489  +
            let error = variant.value(py);
        6490  +
        6491  +
            crate::error::InternalServerError {
        6492  +
                message: error.to_string(),
        6493  +
            }
        6494  +
            .into()
        6495  +
        })
        6496  +
    }
        6497  +
}
        6498  +
        6499  +
/// Error type for the `PutWithContentEncoding` operation.
        6500  +
/// Each variant represents an error that can occur for the `PutWithContentEncoding` operation.
        6501  +
#[derive(::std::fmt::Debug)]
        6502  +
pub enum PutWithContentEncodingError {
        6503  +
    #[allow(missing_docs)] // documentation missing in model
        6504  +
    InternalServerError(crate::error::InternalServerError),
        6505  +
}
        6506  +
impl ::std::fmt::Display for PutWithContentEncodingError {
        6507  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        6508  +
        match &self {
        6509  +
            PutWithContentEncodingError::InternalServerError(_inner) => _inner.fmt(f),
        6510  +
        }
        6511  +
    }
        6512  +
}
        6513  +
impl PutWithContentEncodingError {
        6514  +
    /// Returns `true` if the error kind is `PutWithContentEncodingError::InternalServerError`.
        6515  +
    pub fn is_internal_server_error(&self) -> bool {
        6516  +
        matches!(&self, PutWithContentEncodingError::InternalServerError(_))
        6517  +
    }
        6518  +
    /// Returns the error name string by matching the correct variant.
        6519  +
    pub fn name(&self) -> &'static str {
        6520  +
        match &self {
        6521  +
            PutWithContentEncodingError::InternalServerError(_inner) => _inner.name(),
        6522  +
        }
        6523  +
    }
        6524  +
}
        6525  +
impl ::std::error::Error for PutWithContentEncodingError {
        6526  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        6527  +
        match &self {
        6528  +
            PutWithContentEncodingError::InternalServerError(_inner) => Some(_inner),
        6529  +
        }
 6776   6530   
    }
 6777   6531   
}
 6778   6532   
impl ::std::convert::From<crate::error::InternalServerError>
 6779         -
    for crate::error::InputAndOutputWithHeadersError
        6533  +
    for crate::error::PutWithContentEncodingError
 6780   6534   
{
 6781   6535   
    fn from(
 6782   6536   
        variant: crate::error::InternalServerError,
 6783         -
    ) -> crate::error::InputAndOutputWithHeadersError {
        6537  +
    ) -> crate::error::PutWithContentEncodingError {
 6784   6538   
        Self::InternalServerError(variant)
 6785   6539   
    }
 6786   6540   
}
 6787   6541   
 6788         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::InputAndOutputWithHeadersError {
 6789         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::InputAndOutputWithHeadersError {
        6542  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::PutWithContentEncodingError {
        6543  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::PutWithContentEncodingError {
 6790   6544   
        ::pyo3::Python::with_gil(|py| {
 6791   6545   
            let error = variant.value(py);
 6792         -
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
 6793         -
                return error.into();
 6794         -
            }
        6546  +
 6795   6547   
            crate::error::InternalServerError {
 6796   6548   
                message: error.to_string(),
 6797   6549   
            }
 6798   6550   
            .into()
 6799   6551   
        })
 6800   6552   
    }
 6801   6553   
}
 6802   6554   
 6803         -
/// Error type for the `UnitInputAndOutput` operation.
 6804         -
/// Each variant represents an error that can occur for the `UnitInputAndOutput` operation.
        6555  +
/// Error type for the `ContentTypeParameters` operation.
        6556  +
/// Each variant represents an error that can occur for the `ContentTypeParameters` operation.
 6805   6557   
#[derive(::std::fmt::Debug)]
 6806         -
pub enum UnitInputAndOutputError {
        6558  +
pub enum ContentTypeParametersError {
 6807   6559   
    #[allow(missing_docs)] // documentation missing in model
 6808   6560   
    InternalServerError(crate::error::InternalServerError),
 6809   6561   
}
 6810         -
impl ::std::fmt::Display for UnitInputAndOutputError {
        6562  +
impl ::std::fmt::Display for ContentTypeParametersError {
 6811   6563   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6812   6564   
        match &self {
 6813         -
            UnitInputAndOutputError::InternalServerError(_inner) => _inner.fmt(f),
        6565  +
            ContentTypeParametersError::InternalServerError(_inner) => _inner.fmt(f),
 6814   6566   
        }
 6815   6567   
    }
 6816   6568   
}
 6817         -
impl UnitInputAndOutputError {
 6818         -
    /// Returns `true` if the error kind is `UnitInputAndOutputError::InternalServerError`.
        6569  +
impl ContentTypeParametersError {
        6570  +
    /// Returns `true` if the error kind is `ContentTypeParametersError::InternalServerError`.
 6819   6571   
    pub fn is_internal_server_error(&self) -> bool {
 6820         -
        matches!(&self, UnitInputAndOutputError::InternalServerError(_))
        6572  +
        matches!(&self, ContentTypeParametersError::InternalServerError(_))
 6821   6573   
    }
 6822   6574   
    /// Returns the error name string by matching the correct variant.
 6823   6575   
    pub fn name(&self) -> &'static str {
 6824   6576   
        match &self {
 6825         -
            UnitInputAndOutputError::InternalServerError(_inner) => _inner.name(),
        6577  +
            ContentTypeParametersError::InternalServerError(_inner) => _inner.name(),
 6826   6578   
        }
 6827   6579   
    }
 6828   6580   
}
 6829         -
impl ::std::error::Error for UnitInputAndOutputError {
        6581  +
impl ::std::error::Error for ContentTypeParametersError {
 6830   6582   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6831   6583   
        match &self {
 6832         -
            UnitInputAndOutputError::InternalServerError(_inner) => Some(_inner),
        6584  +
            ContentTypeParametersError::InternalServerError(_inner) => Some(_inner),
 6833   6585   
        }
 6834   6586   
    }
 6835   6587   
}
 6836   6588   
impl ::std::convert::From<crate::error::InternalServerError>
 6837         -
    for crate::error::UnitInputAndOutputError
        6589  +
    for crate::error::ContentTypeParametersError
 6838   6590   
{
 6839         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::UnitInputAndOutputError {
        6591  +
    fn from(
        6592  +
        variant: crate::error::InternalServerError,
        6593  +
    ) -> crate::error::ContentTypeParametersError {
 6840   6594   
        Self::InternalServerError(variant)
 6841   6595   
    }
 6842   6596   
}
 6843   6597   
 6844         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::UnitInputAndOutputError {
 6845         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::UnitInputAndOutputError {
        6598  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::ContentTypeParametersError {
        6599  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::ContentTypeParametersError {
 6846   6600   
        ::pyo3::Python::with_gil(|py| {
 6847   6601   
            let error = variant.value(py);
 6848   6602   
 6849   6603   
            crate::error::InternalServerError {
 6850   6604   
                message: error.to_string(),
 6851   6605   
            }
 6852   6606   
            .into()
 6853   6607   
        })
 6854   6608   
    }
 6855   6609   
}
 6856   6610   
 6857         -
/// Error type for the `EmptyInputAndEmptyOutput` operation.
 6858         -
/// Each variant represents an error that can occur for the `EmptyInputAndEmptyOutput` operation.
        6611  +
/// Error type for the `OperationWithDefaults` operation.
        6612  +
/// Each variant represents an error that can occur for the `OperationWithDefaults` operation.
 6859   6613   
#[derive(::std::fmt::Debug)]
 6860         -
pub enum EmptyInputAndEmptyOutputError {
        6614  +
pub enum OperationWithDefaultsError {
        6615  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        6616  +
    ValidationException(crate::error::ValidationException),
 6861   6617   
    #[allow(missing_docs)] // documentation missing in model
 6862   6618   
    InternalServerError(crate::error::InternalServerError),
 6863   6619   
}
 6864         -
impl ::std::fmt::Display for EmptyInputAndEmptyOutputError {
        6620  +
impl ::std::fmt::Display for OperationWithDefaultsError {
 6865   6621   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6866   6622   
        match &self {
 6867         -
            EmptyInputAndEmptyOutputError::InternalServerError(_inner) => _inner.fmt(f),
        6623  +
            OperationWithDefaultsError::ValidationException(_inner) => _inner.fmt(f),
        6624  +
            OperationWithDefaultsError::InternalServerError(_inner) => _inner.fmt(f),
        6625  +
        }
        6626  +
    }
        6627  +
}
        6628  +
impl OperationWithDefaultsError {
        6629  +
    /// Returns `true` if the error kind is `OperationWithDefaultsError::ValidationException`.
        6630  +
    pub fn is_validation_exception(&self) -> bool {
        6631  +
        matches!(&self, OperationWithDefaultsError::ValidationException(_))
        6632  +
    }
        6633  +
    /// Returns `true` if the error kind is `OperationWithDefaultsError::InternalServerError`.
        6634  +
    pub fn is_internal_server_error(&self) -> bool {
        6635  +
        matches!(&self, OperationWithDefaultsError::InternalServerError(_))
        6636  +
    }
        6637  +
    /// Returns the error name string by matching the correct variant.
        6638  +
    pub fn name(&self) -> &'static str {
        6639  +
        match &self {
        6640  +
            OperationWithDefaultsError::ValidationException(_inner) => _inner.name(),
        6641  +
            OperationWithDefaultsError::InternalServerError(_inner) => _inner.name(),
        6642  +
        }
        6643  +
    }
        6644  +
}
        6645  +
impl ::std::error::Error for OperationWithDefaultsError {
        6646  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        6647  +
        match &self {
        6648  +
            OperationWithDefaultsError::ValidationException(_inner) => Some(_inner),
        6649  +
            OperationWithDefaultsError::InternalServerError(_inner) => Some(_inner),
 6868   6650   
        }
 6869   6651   
    }
 6870   6652   
}
 6871         -
impl EmptyInputAndEmptyOutputError {
 6872         -
    /// Returns `true` if the error kind is `EmptyInputAndEmptyOutputError::InternalServerError`.
 6873         -
    pub fn is_internal_server_error(&self) -> bool {
 6874         -
        matches!(&self, EmptyInputAndEmptyOutputError::InternalServerError(_))
        6653  +
impl ::std::convert::From<crate::error::ValidationException>
        6654  +
    for crate::error::OperationWithDefaultsError
        6655  +
{
        6656  +
    fn from(
        6657  +
        variant: crate::error::ValidationException,
        6658  +
    ) -> crate::error::OperationWithDefaultsError {
        6659  +
        Self::ValidationException(variant)
        6660  +
    }
        6661  +
}
        6662  +
impl ::std::convert::From<crate::error::InternalServerError>
        6663  +
    for crate::error::OperationWithDefaultsError
        6664  +
{
        6665  +
    fn from(
        6666  +
        variant: crate::error::InternalServerError,
        6667  +
    ) -> crate::error::OperationWithDefaultsError {
        6668  +
        Self::InternalServerError(variant)
        6669  +
    }
        6670  +
}
        6671  +
        6672  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OperationWithDefaultsError {
        6673  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::OperationWithDefaultsError {
        6674  +
        ::pyo3::Python::with_gil(|py| {
        6675  +
            let error = variant.value(py);
        6676  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        6677  +
                return error.into();
        6678  +
            }
        6679  +
            crate::error::InternalServerError {
        6680  +
                message: error.to_string(),
        6681  +
            }
        6682  +
            .into()
        6683  +
        })
        6684  +
    }
        6685  +
}
        6686  +
        6687  +
/// Error type for the `OperationWithNestedStructure` operation.
        6688  +
/// Each variant represents an error that can occur for the `OperationWithNestedStructure` operation.
        6689  +
#[derive(::std::fmt::Debug)]
        6690  +
pub enum OperationWithNestedStructureError {
        6691  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        6692  +
    ValidationException(crate::error::ValidationException),
        6693  +
    #[allow(missing_docs)] // documentation missing in model
        6694  +
    InternalServerError(crate::error::InternalServerError),
        6695  +
}
        6696  +
impl ::std::fmt::Display for OperationWithNestedStructureError {
        6697  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        6698  +
        match &self {
        6699  +
            OperationWithNestedStructureError::ValidationException(_inner) => _inner.fmt(f),
        6700  +
            OperationWithNestedStructureError::InternalServerError(_inner) => _inner.fmt(f),
        6701  +
        }
        6702  +
    }
        6703  +
}
        6704  +
impl OperationWithNestedStructureError {
        6705  +
    /// Returns `true` if the error kind is `OperationWithNestedStructureError::ValidationException`.
        6706  +
    pub fn is_validation_exception(&self) -> bool {
        6707  +
        matches!(
        6708  +
            &self,
        6709  +
            OperationWithNestedStructureError::ValidationException(_)
        6710  +
        )
        6711  +
    }
        6712  +
    /// Returns `true` if the error kind is `OperationWithNestedStructureError::InternalServerError`.
        6713  +
    pub fn is_internal_server_error(&self) -> bool {
        6714  +
        matches!(
        6715  +
            &self,
        6716  +
            OperationWithNestedStructureError::InternalServerError(_)
        6717  +
        )
        6718  +
    }
        6719  +
    /// Returns the error name string by matching the correct variant.
        6720  +
    pub fn name(&self) -> &'static str {
        6721  +
        match &self {
        6722  +
            OperationWithNestedStructureError::ValidationException(_inner) => _inner.name(),
        6723  +
            OperationWithNestedStructureError::InternalServerError(_inner) => _inner.name(),
        6724  +
        }
        6725  +
    }
        6726  +
}
        6727  +
impl ::std::error::Error for OperationWithNestedStructureError {
        6728  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        6729  +
        match &self {
        6730  +
            OperationWithNestedStructureError::ValidationException(_inner) => Some(_inner),
        6731  +
            OperationWithNestedStructureError::InternalServerError(_inner) => Some(_inner),
        6732  +
        }
        6733  +
    }
        6734  +
}
        6735  +
impl ::std::convert::From<crate::error::ValidationException>
        6736  +
    for crate::error::OperationWithNestedStructureError
        6737  +
{
        6738  +
    fn from(
        6739  +
        variant: crate::error::ValidationException,
        6740  +
    ) -> crate::error::OperationWithNestedStructureError {
        6741  +
        Self::ValidationException(variant)
        6742  +
    }
        6743  +
}
        6744  +
impl ::std::convert::From<crate::error::InternalServerError>
        6745  +
    for crate::error::OperationWithNestedStructureError
        6746  +
{
        6747  +
    fn from(
        6748  +
        variant: crate::error::InternalServerError,
        6749  +
    ) -> crate::error::OperationWithNestedStructureError {
        6750  +
        Self::InternalServerError(variant)
        6751  +
    }
        6752  +
}
        6753  +
        6754  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OperationWithNestedStructureError {
        6755  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::OperationWithNestedStructureError {
        6756  +
        ::pyo3::Python::with_gil(|py| {
        6757  +
            let error = variant.value(py);
        6758  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        6759  +
                return error.into();
        6760  +
            }
        6761  +
            crate::error::InternalServerError {
        6762  +
                message: error.to_string(),
        6763  +
            }
        6764  +
            .into()
        6765  +
        })
        6766  +
    }
        6767  +
}
        6768  +
        6769  +
/// Error type for the `InputStream` operation.
        6770  +
/// Each variant represents an error that can occur for the `InputStream` operation.
        6771  +
#[derive(::std::fmt::Debug)]
        6772  +
pub enum InputStreamError {
        6773  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        6774  +
    ValidationException(crate::error::ValidationException),
        6775  +
    #[allow(missing_docs)] // documentation missing in model
        6776  +
    ErrorEvent(crate::error::ErrorEvent),
        6777  +
    #[allow(missing_docs)] // documentation missing in model
        6778  +
    InternalServerError(crate::error::InternalServerError),
        6779  +
}
        6780  +
impl ::std::fmt::Display for InputStreamError {
        6781  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        6782  +
        match &self {
        6783  +
            InputStreamError::ValidationException(_inner) => _inner.fmt(f),
        6784  +
            InputStreamError::ErrorEvent(_inner) => _inner.fmt(f),
        6785  +
            InputStreamError::InternalServerError(_inner) => _inner.fmt(f),
        6786  +
        }
        6787  +
    }
        6788  +
}
        6789  +
impl InputStreamError {
        6790  +
    /// Returns `true` if the error kind is `InputStreamError::ValidationException`.
        6791  +
    pub fn is_validation_exception(&self) -> bool {
        6792  +
        matches!(&self, InputStreamError::ValidationException(_))
        6793  +
    }
        6794  +
    /// Returns `true` if the error kind is `InputStreamError::ErrorEvent`.
        6795  +
    pub fn is_error_event(&self) -> bool {
        6796  +
        matches!(&self, InputStreamError::ErrorEvent(_))
        6797  +
    }
        6798  +
    /// Returns `true` if the error kind is `InputStreamError::InternalServerError`.
        6799  +
    pub fn is_internal_server_error(&self) -> bool {
        6800  +
        matches!(&self, InputStreamError::InternalServerError(_))
        6801  +
    }
        6802  +
    /// Returns the error name string by matching the correct variant.
        6803  +
    pub fn name(&self) -> &'static str {
        6804  +
        match &self {
        6805  +
            InputStreamError::ValidationException(_inner) => _inner.name(),
        6806  +
            InputStreamError::ErrorEvent(_inner) => _inner.name(),
        6807  +
            InputStreamError::InternalServerError(_inner) => _inner.name(),
        6808  +
        }
        6809  +
    }
        6810  +
}
        6811  +
impl ::std::error::Error for InputStreamError {
        6812  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        6813  +
        match &self {
        6814  +
            InputStreamError::ValidationException(_inner) => Some(_inner),
        6815  +
            InputStreamError::ErrorEvent(_inner) => Some(_inner),
        6816  +
            InputStreamError::InternalServerError(_inner) => Some(_inner),
        6817  +
        }
        6818  +
    }
        6819  +
}
        6820  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::InputStreamError {
        6821  +
    fn from(variant: crate::error::ValidationException) -> crate::error::InputStreamError {
        6822  +
        Self::ValidationException(variant)
        6823  +
    }
        6824  +
}
        6825  +
impl ::std::convert::From<crate::error::ErrorEvent> for crate::error::InputStreamError {
        6826  +
    fn from(variant: crate::error::ErrorEvent) -> crate::error::InputStreamError {
        6827  +
        Self::ErrorEvent(variant)
        6828  +
    }
        6829  +
}
        6830  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::InputStreamError {
        6831  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::InputStreamError {
        6832  +
        Self::InternalServerError(variant)
        6833  +
    }
        6834  +
}
        6835  +
        6836  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::InputStreamError {
        6837  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::InputStreamError {
        6838  +
        ::pyo3::Python::with_gil(|py| {
        6839  +
            let error = variant.value(py);
        6840  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        6841  +
                return error.into();
        6842  +
            }
        6843  +
            if let Ok(error) = error.extract::<crate::error::ErrorEvent>() {
        6844  +
                return error.into();
        6845  +
            }
        6846  +
            crate::error::InternalServerError {
        6847  +
                message: error.to_string(),
        6848  +
            }
        6849  +
            .into()
        6850  +
        })
        6851  +
    }
        6852  +
}
        6853  +
        6854  +
/// Error type for the `OutputStream` operation.
        6855  +
/// Each variant represents an error that can occur for the `OutputStream` operation.
        6856  +
#[derive(::std::fmt::Debug)]
        6857  +
pub enum OutputStreamError {
        6858  +
    #[allow(missing_docs)] // documentation missing in model
        6859  +
    ServiceUnavailableError(crate::error::ServiceUnavailableError),
        6860  +
    #[allow(missing_docs)] // documentation missing in model
        6861  +
    ErrorEvent(crate::error::ErrorEvent),
        6862  +
    #[allow(missing_docs)] // documentation missing in model
        6863  +
    InternalServerError(crate::error::InternalServerError),
        6864  +
}
        6865  +
impl ::std::fmt::Display for OutputStreamError {
        6866  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        6867  +
        match &self {
        6868  +
            OutputStreamError::ServiceUnavailableError(_inner) => _inner.fmt(f),
        6869  +
            OutputStreamError::ErrorEvent(_inner) => _inner.fmt(f),
        6870  +
            OutputStreamError::InternalServerError(_inner) => _inner.fmt(f),
        6871  +
        }
        6872  +
    }
        6873  +
}
        6874  +
impl OutputStreamError {
        6875  +
    /// Returns `true` if the error kind is `OutputStreamError::ServiceUnavailableError`.
        6876  +
    pub fn is_service_unavailable_error(&self) -> bool {
        6877  +
        matches!(&self, OutputStreamError::ServiceUnavailableError(_))
        6878  +
    }
        6879  +
    /// Returns `true` if the error kind is `OutputStreamError::ErrorEvent`.
        6880  +
    pub fn is_error_event(&self) -> bool {
        6881  +
        matches!(&self, OutputStreamError::ErrorEvent(_))
        6882  +
    }
        6883  +
    /// Returns `true` if the error kind is `OutputStreamError::InternalServerError`.
        6884  +
    pub fn is_internal_server_error(&self) -> bool {
        6885  +
        matches!(&self, OutputStreamError::InternalServerError(_))
        6886  +
    }
        6887  +
    /// Returns the error name string by matching the correct variant.
        6888  +
    pub fn name(&self) -> &'static str {
        6889  +
        match &self {
        6890  +
            OutputStreamError::ServiceUnavailableError(_inner) => _inner.name(),
        6891  +
            OutputStreamError::ErrorEvent(_inner) => _inner.name(),
        6892  +
            OutputStreamError::InternalServerError(_inner) => _inner.name(),
        6893  +
        }
        6894  +
    }
        6895  +
}
        6896  +
impl ::std::error::Error for OutputStreamError {
        6897  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        6898  +
        match &self {
        6899  +
            OutputStreamError::ServiceUnavailableError(_inner) => Some(_inner),
        6900  +
            OutputStreamError::ErrorEvent(_inner) => Some(_inner),
        6901  +
            OutputStreamError::InternalServerError(_inner) => Some(_inner),
        6902  +
        }
        6903  +
    }
        6904  +
}
        6905  +
impl ::std::convert::From<crate::error::ServiceUnavailableError>
        6906  +
    for crate::error::OutputStreamError
        6907  +
{
        6908  +
    fn from(variant: crate::error::ServiceUnavailableError) -> crate::error::OutputStreamError {
        6909  +
        Self::ServiceUnavailableError(variant)
        6910  +
    }
        6911  +
}
        6912  +
impl ::std::convert::From<crate::error::ErrorEvent> for crate::error::OutputStreamError {
        6913  +
    fn from(variant: crate::error::ErrorEvent) -> crate::error::OutputStreamError {
        6914  +
        Self::ErrorEvent(variant)
        6915  +
    }
        6916  +
}
        6917  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::OutputStreamError {
        6918  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::OutputStreamError {
        6919  +
        Self::InternalServerError(variant)
        6920  +
    }
        6921  +
}
        6922  +
        6923  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OutputStreamError {
        6924  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::OutputStreamError {
        6925  +
        ::pyo3::Python::with_gil(|py| {
        6926  +
            let error = variant.value(py);
        6927  +
            if let Ok(error) = error.extract::<crate::error::ServiceUnavailableError>() {
        6928  +
                return error.into();
        6929  +
            }
        6930  +
            if let Ok(error) = error.extract::<crate::error::ErrorEvent>() {
        6931  +
                return error.into();
        6932  +
            }
        6933  +
            crate::error::InternalServerError {
        6934  +
                message: error.to_string(),
        6935  +
            }
        6936  +
            .into()
        6937  +
        })
        6938  +
    }
        6939  +
}
        6940  +
        6941  +
/// Error type for the `DuplexStream` operation.
        6942  +
/// Each variant represents an error that can occur for the `DuplexStream` operation.
        6943  +
#[derive(::std::fmt::Debug)]
        6944  +
pub enum DuplexStreamError {
        6945  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        6946  +
    ValidationException(crate::error::ValidationException),
        6947  +
    #[allow(missing_docs)] // documentation missing in model
        6948  +
    ErrorEvent(crate::error::ErrorEvent),
        6949  +
    #[allow(missing_docs)] // documentation missing in model
        6950  +
    InternalServerError(crate::error::InternalServerError),
        6951  +
}
        6952  +
impl ::std::fmt::Display for DuplexStreamError {
        6953  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        6954  +
        match &self {
        6955  +
            DuplexStreamError::ValidationException(_inner) => _inner.fmt(f),
        6956  +
            DuplexStreamError::ErrorEvent(_inner) => _inner.fmt(f),
        6957  +
            DuplexStreamError::InternalServerError(_inner) => _inner.fmt(f),
        6958  +
        }
        6959  +
    }
        6960  +
}
        6961  +
impl DuplexStreamError {
        6962  +
    /// Returns `true` if the error kind is `DuplexStreamError::ValidationException`.
        6963  +
    pub fn is_validation_exception(&self) -> bool {
        6964  +
        matches!(&self, DuplexStreamError::ValidationException(_))
        6965  +
    }
        6966  +
    /// Returns `true` if the error kind is `DuplexStreamError::ErrorEvent`.
        6967  +
    pub fn is_error_event(&self) -> bool {
        6968  +
        matches!(&self, DuplexStreamError::ErrorEvent(_))
        6969  +
    }
        6970  +
    /// Returns `true` if the error kind is `DuplexStreamError::InternalServerError`.
        6971  +
    pub fn is_internal_server_error(&self) -> bool {
        6972  +
        matches!(&self, DuplexStreamError::InternalServerError(_))
        6973  +
    }
        6974  +
    /// Returns the error name string by matching the correct variant.
        6975  +
    pub fn name(&self) -> &'static str {
        6976  +
        match &self {
        6977  +
            DuplexStreamError::ValidationException(_inner) => _inner.name(),
        6978  +
            DuplexStreamError::ErrorEvent(_inner) => _inner.name(),
        6979  +
            DuplexStreamError::InternalServerError(_inner) => _inner.name(),
        6980  +
        }
        6981  +
    }
        6982  +
}
        6983  +
impl ::std::error::Error for DuplexStreamError {
        6984  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        6985  +
        match &self {
        6986  +
            DuplexStreamError::ValidationException(_inner) => Some(_inner),
        6987  +
            DuplexStreamError::ErrorEvent(_inner) => Some(_inner),
        6988  +
            DuplexStreamError::InternalServerError(_inner) => Some(_inner),
        6989  +
        }
        6990  +
    }
        6991  +
}
        6992  +
impl ::std::convert::From<crate::error::ValidationException> for crate::error::DuplexStreamError {
        6993  +
    fn from(variant: crate::error::ValidationException) -> crate::error::DuplexStreamError {
        6994  +
        Self::ValidationException(variant)
        6995  +
    }
        6996  +
}
        6997  +
impl ::std::convert::From<crate::error::ErrorEvent> for crate::error::DuplexStreamError {
        6998  +
    fn from(variant: crate::error::ErrorEvent) -> crate::error::DuplexStreamError {
        6999  +
        Self::ErrorEvent(variant)
        7000  +
    }
        7001  +
}
        7002  +
impl ::std::convert::From<crate::error::InternalServerError> for crate::error::DuplexStreamError {
        7003  +
    fn from(variant: crate::error::InternalServerError) -> crate::error::DuplexStreamError {
        7004  +
        Self::InternalServerError(variant)
        7005  +
    }
        7006  +
}
        7007  +
        7008  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DuplexStreamError {
        7009  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::DuplexStreamError {
        7010  +
        ::pyo3::Python::with_gil(|py| {
        7011  +
            let error = variant.value(py);
        7012  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        7013  +
                return error.into();
        7014  +
            }
        7015  +
            if let Ok(error) = error.extract::<crate::error::ErrorEvent>() {
        7016  +
                return error.into();
        7017  +
            }
        7018  +
            crate::error::InternalServerError {
        7019  +
                message: error.to_string(),
        7020  +
            }
        7021  +
            .into()
        7022  +
        })
        7023  +
    }
        7024  +
}
        7025  +
        7026  +
/// Error type for the `InputStreamWithInitialRequest` operation.
        7027  +
/// Each variant represents an error that can occur for the `InputStreamWithInitialRequest` operation.
        7028  +
#[derive(::std::fmt::Debug)]
        7029  +
pub enum InputStreamWithInitialRequestError {
        7030  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        7031  +
    ValidationException(crate::error::ValidationException),
        7032  +
    #[allow(missing_docs)] // documentation missing in model
        7033  +
    ErrorEvent(crate::error::ErrorEvent),
        7034  +
    #[allow(missing_docs)] // documentation missing in model
        7035  +
    InternalServerError(crate::error::InternalServerError),
        7036  +
}
        7037  +
impl ::std::fmt::Display for InputStreamWithInitialRequestError {
        7038  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7039  +
        match &self {
        7040  +
            InputStreamWithInitialRequestError::ValidationException(_inner) => _inner.fmt(f),
        7041  +
            InputStreamWithInitialRequestError::ErrorEvent(_inner) => _inner.fmt(f),
        7042  +
            InputStreamWithInitialRequestError::InternalServerError(_inner) => _inner.fmt(f),
        7043  +
        }
        7044  +
    }
        7045  +
}
        7046  +
impl InputStreamWithInitialRequestError {
        7047  +
    /// Returns `true` if the error kind is `InputStreamWithInitialRequestError::ValidationException`.
        7048  +
    pub fn is_validation_exception(&self) -> bool {
        7049  +
        matches!(
        7050  +
            &self,
        7051  +
            InputStreamWithInitialRequestError::ValidationException(_)
        7052  +
        )
        7053  +
    }
        7054  +
    /// Returns `true` if the error kind is `InputStreamWithInitialRequestError::ErrorEvent`.
        7055  +
    pub fn is_error_event(&self) -> bool {
        7056  +
        matches!(&self, InputStreamWithInitialRequestError::ErrorEvent(_))
        7057  +
    }
        7058  +
    /// Returns `true` if the error kind is `InputStreamWithInitialRequestError::InternalServerError`.
        7059  +
    pub fn is_internal_server_error(&self) -> bool {
        7060  +
        matches!(
        7061  +
            &self,
        7062  +
            InputStreamWithInitialRequestError::InternalServerError(_)
        7063  +
        )
        7064  +
    }
        7065  +
    /// Returns the error name string by matching the correct variant.
        7066  +
    pub fn name(&self) -> &'static str {
        7067  +
        match &self {
        7068  +
            InputStreamWithInitialRequestError::ValidationException(_inner) => _inner.name(),
        7069  +
            InputStreamWithInitialRequestError::ErrorEvent(_inner) => _inner.name(),
        7070  +
            InputStreamWithInitialRequestError::InternalServerError(_inner) => _inner.name(),
        7071  +
        }
        7072  +
    }
        7073  +
}
        7074  +
impl ::std::error::Error for InputStreamWithInitialRequestError {
        7075  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        7076  +
        match &self {
        7077  +
            InputStreamWithInitialRequestError::ValidationException(_inner) => Some(_inner),
        7078  +
            InputStreamWithInitialRequestError::ErrorEvent(_inner) => Some(_inner),
        7079  +
            InputStreamWithInitialRequestError::InternalServerError(_inner) => Some(_inner),
        7080  +
        }
        7081  +
    }
        7082  +
}
        7083  +
impl ::std::convert::From<crate::error::ValidationException>
        7084  +
    for crate::error::InputStreamWithInitialRequestError
        7085  +
{
        7086  +
    fn from(
        7087  +
        variant: crate::error::ValidationException,
        7088  +
    ) -> crate::error::InputStreamWithInitialRequestError {
        7089  +
        Self::ValidationException(variant)
        7090  +
    }
        7091  +
}
        7092  +
impl ::std::convert::From<crate::error::ErrorEvent>
        7093  +
    for crate::error::InputStreamWithInitialRequestError
        7094  +
{
        7095  +
    fn from(variant: crate::error::ErrorEvent) -> crate::error::InputStreamWithInitialRequestError {
        7096  +
        Self::ErrorEvent(variant)
        7097  +
    }
        7098  +
}
        7099  +
impl ::std::convert::From<crate::error::InternalServerError>
        7100  +
    for crate::error::InputStreamWithInitialRequestError
        7101  +
{
        7102  +
    fn from(
        7103  +
        variant: crate::error::InternalServerError,
        7104  +
    ) -> crate::error::InputStreamWithInitialRequestError {
        7105  +
        Self::InternalServerError(variant)
        7106  +
    }
        7107  +
}
        7108  +
        7109  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::InputStreamWithInitialRequestError {
        7110  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::InputStreamWithInitialRequestError {
        7111  +
        ::pyo3::Python::with_gil(|py| {
        7112  +
            let error = variant.value(py);
        7113  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        7114  +
                return error.into();
        7115  +
            }
        7116  +
            if let Ok(error) = error.extract::<crate::error::ErrorEvent>() {
        7117  +
                return error.into();
        7118  +
            }
        7119  +
            crate::error::InternalServerError {
        7120  +
                message: error.to_string(),
        7121  +
            }
        7122  +
            .into()
        7123  +
        })
        7124  +
    }
        7125  +
}
        7126  +
        7127  +
/// Error type for the `OutputStreamWithInitialResponse` operation.
        7128  +
/// Each variant represents an error that can occur for the `OutputStreamWithInitialResponse` operation.
        7129  +
#[derive(::std::fmt::Debug)]
        7130  +
pub enum OutputStreamWithInitialResponseError {
        7131  +
    #[allow(missing_docs)] // documentation missing in model
        7132  +
    ErrorEvent(crate::error::ErrorEvent),
        7133  +
    #[allow(missing_docs)] // documentation missing in model
        7134  +
    InternalServerError(crate::error::InternalServerError),
        7135  +
}
        7136  +
impl ::std::fmt::Display for OutputStreamWithInitialResponseError {
        7137  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7138  +
        match &self {
        7139  +
            OutputStreamWithInitialResponseError::ErrorEvent(_inner) => _inner.fmt(f),
        7140  +
            OutputStreamWithInitialResponseError::InternalServerError(_inner) => _inner.fmt(f),
        7141  +
        }
        7142  +
    }
        7143  +
}
        7144  +
impl OutputStreamWithInitialResponseError {
        7145  +
    /// Returns `true` if the error kind is `OutputStreamWithInitialResponseError::ErrorEvent`.
        7146  +
    pub fn is_error_event(&self) -> bool {
        7147  +
        matches!(&self, OutputStreamWithInitialResponseError::ErrorEvent(_))
        7148  +
    }
        7149  +
    /// Returns `true` if the error kind is `OutputStreamWithInitialResponseError::InternalServerError`.
        7150  +
    pub fn is_internal_server_error(&self) -> bool {
        7151  +
        matches!(
        7152  +
            &self,
        7153  +
            OutputStreamWithInitialResponseError::InternalServerError(_)
        7154  +
        )
        7155  +
    }
        7156  +
    /// Returns the error name string by matching the correct variant.
        7157  +
    pub fn name(&self) -> &'static str {
        7158  +
        match &self {
        7159  +
            OutputStreamWithInitialResponseError::ErrorEvent(_inner) => _inner.name(),
        7160  +
            OutputStreamWithInitialResponseError::InternalServerError(_inner) => _inner.name(),
        7161  +
        }
        7162  +
    }
        7163  +
}
        7164  +
impl ::std::error::Error for OutputStreamWithInitialResponseError {
        7165  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        7166  +
        match &self {
        7167  +
            OutputStreamWithInitialResponseError::ErrorEvent(_inner) => Some(_inner),
        7168  +
            OutputStreamWithInitialResponseError::InternalServerError(_inner) => Some(_inner),
        7169  +
        }
        7170  +
    }
        7171  +
}
        7172  +
impl ::std::convert::From<crate::error::ErrorEvent>
        7173  +
    for crate::error::OutputStreamWithInitialResponseError
        7174  +
{
        7175  +
    fn from(
        7176  +
        variant: crate::error::ErrorEvent,
        7177  +
    ) -> crate::error::OutputStreamWithInitialResponseError {
        7178  +
        Self::ErrorEvent(variant)
        7179  +
    }
        7180  +
}
        7181  +
impl ::std::convert::From<crate::error::InternalServerError>
        7182  +
    for crate::error::OutputStreamWithInitialResponseError
        7183  +
{
        7184  +
    fn from(
        7185  +
        variant: crate::error::InternalServerError,
        7186  +
    ) -> crate::error::OutputStreamWithInitialResponseError {
        7187  +
        Self::InternalServerError(variant)
        7188  +
    }
        7189  +
}
        7190  +
        7191  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::OutputStreamWithInitialResponseError {
        7192  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::OutputStreamWithInitialResponseError {
        7193  +
        ::pyo3::Python::with_gil(|py| {
        7194  +
            let error = variant.value(py);
        7195  +
            if let Ok(error) = error.extract::<crate::error::ErrorEvent>() {
        7196  +
                return error.into();
        7197  +
            }
        7198  +
            crate::error::InternalServerError {
        7199  +
                message: error.to_string(),
        7200  +
            }
        7201  +
            .into()
        7202  +
        })
        7203  +
    }
        7204  +
}
        7205  +
        7206  +
/// Error type for the `DuplexStreamWithInitialMessages` operation.
        7207  +
/// Each variant represents an error that can occur for the `DuplexStreamWithInitialMessages` operation.
        7208  +
#[derive(::std::fmt::Debug)]
        7209  +
pub enum DuplexStreamWithInitialMessagesError {
        7210  +
    #[allow(missing_docs)] // documentation missing in model
        7211  +
    ServiceUnavailableError(crate::error::ServiceUnavailableError),
        7212  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        7213  +
    ValidationException(crate::error::ValidationException),
        7214  +
    #[allow(missing_docs)] // documentation missing in model
        7215  +
    ErrorEvent(crate::error::ErrorEvent),
        7216  +
    #[allow(missing_docs)] // documentation missing in model
        7217  +
    InternalServerError(crate::error::InternalServerError),
        7218  +
}
        7219  +
impl ::std::fmt::Display for DuplexStreamWithInitialMessagesError {
        7220  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7221  +
        match &self {
        7222  +
            DuplexStreamWithInitialMessagesError::ServiceUnavailableError(_inner) => _inner.fmt(f),
        7223  +
            DuplexStreamWithInitialMessagesError::ValidationException(_inner) => _inner.fmt(f),
        7224  +
            DuplexStreamWithInitialMessagesError::ErrorEvent(_inner) => _inner.fmt(f),
        7225  +
            DuplexStreamWithInitialMessagesError::InternalServerError(_inner) => _inner.fmt(f),
        7226  +
        }
        7227  +
    }
        7228  +
}
        7229  +
impl DuplexStreamWithInitialMessagesError {
        7230  +
    /// Returns `true` if the error kind is `DuplexStreamWithInitialMessagesError::ServiceUnavailableError`.
        7231  +
    pub fn is_service_unavailable_error(&self) -> bool {
        7232  +
        matches!(
        7233  +
            &self,
        7234  +
            DuplexStreamWithInitialMessagesError::ServiceUnavailableError(_)
        7235  +
        )
        7236  +
    }
        7237  +
    /// Returns `true` if the error kind is `DuplexStreamWithInitialMessagesError::ValidationException`.
        7238  +
    pub fn is_validation_exception(&self) -> bool {
        7239  +
        matches!(
        7240  +
            &self,
        7241  +
            DuplexStreamWithInitialMessagesError::ValidationException(_)
        7242  +
        )
        7243  +
    }
        7244  +
    /// Returns `true` if the error kind is `DuplexStreamWithInitialMessagesError::ErrorEvent`.
        7245  +
    pub fn is_error_event(&self) -> bool {
        7246  +
        matches!(&self, DuplexStreamWithInitialMessagesError::ErrorEvent(_))
        7247  +
    }
        7248  +
    /// Returns `true` if the error kind is `DuplexStreamWithInitialMessagesError::InternalServerError`.
        7249  +
    pub fn is_internal_server_error(&self) -> bool {
        7250  +
        matches!(
        7251  +
            &self,
        7252  +
            DuplexStreamWithInitialMessagesError::InternalServerError(_)
        7253  +
        )
        7254  +
    }
        7255  +
    /// Returns the error name string by matching the correct variant.
        7256  +
    pub fn name(&self) -> &'static str {
        7257  +
        match &self {
        7258  +
            DuplexStreamWithInitialMessagesError::ServiceUnavailableError(_inner) => _inner.name(),
        7259  +
            DuplexStreamWithInitialMessagesError::ValidationException(_inner) => _inner.name(),
        7260  +
            DuplexStreamWithInitialMessagesError::ErrorEvent(_inner) => _inner.name(),
        7261  +
            DuplexStreamWithInitialMessagesError::InternalServerError(_inner) => _inner.name(),
        7262  +
        }
        7263  +
    }
        7264  +
}
        7265  +
impl ::std::error::Error for DuplexStreamWithInitialMessagesError {
        7266  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        7267  +
        match &self {
        7268  +
            DuplexStreamWithInitialMessagesError::ServiceUnavailableError(_inner) => Some(_inner),
        7269  +
            DuplexStreamWithInitialMessagesError::ValidationException(_inner) => Some(_inner),
        7270  +
            DuplexStreamWithInitialMessagesError::ErrorEvent(_inner) => Some(_inner),
        7271  +
            DuplexStreamWithInitialMessagesError::InternalServerError(_inner) => Some(_inner),
        7272  +
        }
        7273  +
    }
        7274  +
}
        7275  +
impl ::std::convert::From<crate::error::ServiceUnavailableError>
        7276  +
    for crate::error::DuplexStreamWithInitialMessagesError
        7277  +
{
        7278  +
    fn from(
        7279  +
        variant: crate::error::ServiceUnavailableError,
        7280  +
    ) -> crate::error::DuplexStreamWithInitialMessagesError {
        7281  +
        Self::ServiceUnavailableError(variant)
        7282  +
    }
        7283  +
}
        7284  +
impl ::std::convert::From<crate::error::ValidationException>
        7285  +
    for crate::error::DuplexStreamWithInitialMessagesError
        7286  +
{
        7287  +
    fn from(
        7288  +
        variant: crate::error::ValidationException,
        7289  +
    ) -> crate::error::DuplexStreamWithInitialMessagesError {
        7290  +
        Self::ValidationException(variant)
        7291  +
    }
        7292  +
}
        7293  +
impl ::std::convert::From<crate::error::ErrorEvent>
        7294  +
    for crate::error::DuplexStreamWithInitialMessagesError
        7295  +
{
        7296  +
    fn from(
        7297  +
        variant: crate::error::ErrorEvent,
        7298  +
    ) -> crate::error::DuplexStreamWithInitialMessagesError {
        7299  +
        Self::ErrorEvent(variant)
        7300  +
    }
        7301  +
}
        7302  +
impl ::std::convert::From<crate::error::InternalServerError>
        7303  +
    for crate::error::DuplexStreamWithInitialMessagesError
        7304  +
{
        7305  +
    fn from(
        7306  +
        variant: crate::error::InternalServerError,
        7307  +
    ) -> crate::error::DuplexStreamWithInitialMessagesError {
        7308  +
        Self::InternalServerError(variant)
        7309  +
    }
        7310  +
}
        7311  +
        7312  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DuplexStreamWithInitialMessagesError {
        7313  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::DuplexStreamWithInitialMessagesError {
        7314  +
        ::pyo3::Python::with_gil(|py| {
        7315  +
            let error = variant.value(py);
        7316  +
            if let Ok(error) = error.extract::<crate::error::ServiceUnavailableError>() {
        7317  +
                return error.into();
        7318  +
            }
        7319  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        7320  +
                return error.into();
        7321  +
            }
        7322  +
            if let Ok(error) = error.extract::<crate::error::ErrorEvent>() {
        7323  +
                return error.into();
        7324  +
            }
        7325  +
            crate::error::InternalServerError {
        7326  +
                message: error.to_string(),
        7327  +
            }
        7328  +
            .into()
        7329  +
        })
        7330  +
    }
        7331  +
}
        7332  +
        7333  +
/// Error type for the `DuplexStreamWithDistinctStreams` operation.
        7334  +
/// Each variant represents an error that can occur for the `DuplexStreamWithDistinctStreams` operation.
        7335  +
#[derive(::std::fmt::Debug)]
        7336  +
pub enum DuplexStreamWithDistinctStreamsError {
        7337  +
    /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        7338  +
    ValidationException(crate::error::ValidationException),
        7339  +
    #[allow(missing_docs)] // documentation missing in model
        7340  +
    ErrorEvent(crate::error::ErrorEvent),
        7341  +
    #[allow(missing_docs)] // documentation missing in model
        7342  +
    InternalServerError(crate::error::InternalServerError),
        7343  +
}
        7344  +
impl ::std::fmt::Display for DuplexStreamWithDistinctStreamsError {
        7345  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7346  +
        match &self {
        7347  +
            DuplexStreamWithDistinctStreamsError::ValidationException(_inner) => _inner.fmt(f),
        7348  +
            DuplexStreamWithDistinctStreamsError::ErrorEvent(_inner) => _inner.fmt(f),
        7349  +
            DuplexStreamWithDistinctStreamsError::InternalServerError(_inner) => _inner.fmt(f),
        7350  +
        }
        7351  +
    }
        7352  +
}
        7353  +
impl DuplexStreamWithDistinctStreamsError {
        7354  +
    /// Returns `true` if the error kind is `DuplexStreamWithDistinctStreamsError::ValidationException`.
        7355  +
    pub fn is_validation_exception(&self) -> bool {
        7356  +
        matches!(
        7357  +
            &self,
        7358  +
            DuplexStreamWithDistinctStreamsError::ValidationException(_)
        7359  +
        )
        7360  +
    }
        7361  +
    /// Returns `true` if the error kind is `DuplexStreamWithDistinctStreamsError::ErrorEvent`.
        7362  +
    pub fn is_error_event(&self) -> bool {
        7363  +
        matches!(&self, DuplexStreamWithDistinctStreamsError::ErrorEvent(_))
        7364  +
    }
        7365  +
    /// Returns `true` if the error kind is `DuplexStreamWithDistinctStreamsError::InternalServerError`.
        7366  +
    pub fn is_internal_server_error(&self) -> bool {
        7367  +
        matches!(
        7368  +
            &self,
        7369  +
            DuplexStreamWithDistinctStreamsError::InternalServerError(_)
        7370  +
        )
        7371  +
    }
        7372  +
    /// Returns the error name string by matching the correct variant.
        7373  +
    pub fn name(&self) -> &'static str {
        7374  +
        match &self {
        7375  +
            DuplexStreamWithDistinctStreamsError::ValidationException(_inner) => _inner.name(),
        7376  +
            DuplexStreamWithDistinctStreamsError::ErrorEvent(_inner) => _inner.name(),
        7377  +
            DuplexStreamWithDistinctStreamsError::InternalServerError(_inner) => _inner.name(),
        7378  +
        }
        7379  +
    }
        7380  +
}
        7381  +
impl ::std::error::Error for DuplexStreamWithDistinctStreamsError {
        7382  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        7383  +
        match &self {
        7384  +
            DuplexStreamWithDistinctStreamsError::ValidationException(_inner) => Some(_inner),
        7385  +
            DuplexStreamWithDistinctStreamsError::ErrorEvent(_inner) => Some(_inner),
        7386  +
            DuplexStreamWithDistinctStreamsError::InternalServerError(_inner) => Some(_inner),
        7387  +
        }
        7388  +
    }
        7389  +
}
        7390  +
impl ::std::convert::From<crate::error::ValidationException>
        7391  +
    for crate::error::DuplexStreamWithDistinctStreamsError
        7392  +
{
        7393  +
    fn from(
        7394  +
        variant: crate::error::ValidationException,
        7395  +
    ) -> crate::error::DuplexStreamWithDistinctStreamsError {
        7396  +
        Self::ValidationException(variant)
        7397  +
    }
        7398  +
}
        7399  +
impl ::std::convert::From<crate::error::ErrorEvent>
        7400  +
    for crate::error::DuplexStreamWithDistinctStreamsError
        7401  +
{
        7402  +
    fn from(
        7403  +
        variant: crate::error::ErrorEvent,
        7404  +
    ) -> crate::error::DuplexStreamWithDistinctStreamsError {
        7405  +
        Self::ErrorEvent(variant)
        7406  +
    }
        7407  +
}
        7408  +
impl ::std::convert::From<crate::error::InternalServerError>
        7409  +
    for crate::error::DuplexStreamWithDistinctStreamsError
        7410  +
{
        7411  +
    fn from(
        7412  +
        variant: crate::error::InternalServerError,
        7413  +
    ) -> crate::error::DuplexStreamWithDistinctStreamsError {
        7414  +
        Self::InternalServerError(variant)
        7415  +
    }
        7416  +
}
        7417  +
        7418  +
impl ::std::convert::From<::pyo3::PyErr> for crate::error::DuplexStreamWithDistinctStreamsError {
        7419  +
    fn from(variant: ::pyo3::PyErr) -> crate::error::DuplexStreamWithDistinctStreamsError {
        7420  +
        ::pyo3::Python::with_gil(|py| {
        7421  +
            let error = variant.value(py);
        7422  +
            if let Ok(error) = error.extract::<crate::error::ValidationException>() {
        7423  +
                return error.into();
        7424  +
            }
        7425  +
            if let Ok(error) = error.extract::<crate::error::ErrorEvent>() {
        7426  +
                return error.into();
        7427  +
            }
        7428  +
            crate::error::InternalServerError {
        7429  +
                message: error.to_string(),
        7430  +
            }
        7431  +
            .into()
        7432  +
        })
        7433  +
    }
        7434  +
}
        7435  +
        7436  +
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
        7437  +
/// :param message str:
        7438  +
/// :rtype None:
        7439  +
#[allow(missing_docs)] // documentation missing in model
        7440  +
#[derive(
        7441  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
        7442  +
)]
        7443  +
pub struct InternalServerError {
        7444  +
    #[pyo3(get, set)]
        7445  +
    /// :type str:
        7446  +
    #[allow(missing_docs)] // documentation missing in model
        7447  +
    pub message: ::std::string::String,
        7448  +
}
        7449  +
#[allow(clippy::new_without_default)]
        7450  +
#[allow(clippy::too_many_arguments)]
        7451  +
#[::pyo3::pymethods]
        7452  +
impl InternalServerError {
        7453  +
    #[new]
        7454  +
    pub fn new(message: ::std::string::String) -> Self {
        7455  +
        Self { message }
        7456  +
    }
        7457  +
    fn __repr__(&self) -> String {
        7458  +
        format!("{self:?}")
        7459  +
    }
        7460  +
    fn __str__(&self) -> String {
        7461  +
        format!("{self:?}")
        7462  +
    }
        7463  +
}
        7464  +
impl InternalServerError {
        7465  +
    /// Returns the error message.
        7466  +
    pub fn message(&self) -> &str {
        7467  +
        &self.message
        7468  +
    }
        7469  +
    #[doc(hidden)]
        7470  +
    /// Returns the error name.
        7471  +
    pub fn name(&self) -> &'static str {
        7472  +
        "InternalServerError"
        7473  +
    }
        7474  +
}
        7475  +
impl ::std::fmt::Display for InternalServerError {
        7476  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7477  +
        ::std::write!(f, "InternalServerError")?;
        7478  +
        {
        7479  +
            ::std::write!(f, ": {}", &self.message)?;
        7480  +
        }
        7481  +
        Ok(())
        7482  +
    }
        7483  +
}
        7484  +
impl ::std::error::Error for InternalServerError {}
        7485  +
impl InternalServerError {
        7486  +
    /// Creates a new builder-style object to manufacture [`InternalServerError`](crate::error::InternalServerError).
        7487  +
    pub fn builder() -> crate::error::internal_server_error::Builder {
        7488  +
        crate::error::internal_server_error::Builder::default()
        7489  +
    }
        7490  +
}
        7491  +
        7492  +
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
        7493  +
/// :param message str:
        7494  +
/// :param field_list typing.Optional\[typing.List\[rest_json.model.ValidationExceptionField\]\]:
        7495  +
/// :rtype None:
        7496  +
/// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
        7497  +
#[derive(
        7498  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
        7499  +
)]
        7500  +
pub struct ValidationException {
        7501  +
    #[pyo3(get, set)]
        7502  +
    /// :type str:
        7503  +
    /// A summary of the validation failure.
        7504  +
    pub message: ::std::string::String,
        7505  +
    #[pyo3(get, set)]
        7506  +
    /// :type typing.Optional\[typing.List\[rest_json.model.ValidationExceptionField\]\]:
        7507  +
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
        7508  +
    pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
        7509  +
}
        7510  +
impl ValidationException {
        7511  +
    /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
        7512  +
    pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
        7513  +
        self.field_list.as_deref()
        7514  +
    }
        7515  +
}
        7516  +
#[allow(clippy::new_without_default)]
        7517  +
#[allow(clippy::too_many_arguments)]
        7518  +
#[::pyo3::pymethods]
        7519  +
impl ValidationException {
        7520  +
    #[new]
        7521  +
    pub fn new(
        7522  +
        message: ::std::string::String,
        7523  +
        field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
        7524  +
    ) -> Self {
        7525  +
        Self {
        7526  +
            message,
        7527  +
            field_list,
        7528  +
        }
        7529  +
    }
        7530  +
    fn __repr__(&self) -> String {
        7531  +
        format!("{self:?}")
        7532  +
    }
        7533  +
    fn __str__(&self) -> String {
        7534  +
        format!("{self:?}")
        7535  +
    }
        7536  +
}
        7537  +
impl ValidationException {
        7538  +
    /// Returns the error message.
        7539  +
    pub fn message(&self) -> &str {
        7540  +
        &self.message
        7541  +
    }
        7542  +
    #[doc(hidden)]
        7543  +
    /// Returns the error name.
        7544  +
    pub fn name(&self) -> &'static str {
        7545  +
        "ValidationException"
        7546  +
    }
        7547  +
}
        7548  +
impl ::std::fmt::Display for ValidationException {
        7549  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7550  +
        ::std::write!(f, "ValidationException")?;
        7551  +
        {
        7552  +
            ::std::write!(f, ": {}", &self.message)?;
        7553  +
        }
        7554  +
        Ok(())
        7555  +
    }
        7556  +
}
        7557  +
impl ::std::error::Error for ValidationException {}
        7558  +
impl ValidationException {
        7559  +
    /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
        7560  +
    pub fn builder() -> crate::error::validation_exception::Builder {
        7561  +
        crate::error::validation_exception::Builder::default()
        7562  +
    }
        7563  +
}
        7564  +
        7565  +
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
        7566  +
/// :param message typing.Optional\[str\]:
        7567  +
/// :rtype None:
        7568  +
/// This error is thrown when an invalid greeting value is provided.
        7569  +
#[derive(
        7570  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
        7571  +
)]
        7572  +
pub struct InvalidGreeting {
        7573  +
    #[pyo3(get, set)]
        7574  +
    /// :type typing.Optional\[str\]:
        7575  +
    #[allow(missing_docs)] // documentation missing in model
        7576  +
    pub message: ::std::option::Option<::std::string::String>,
        7577  +
}
        7578  +
#[allow(clippy::new_without_default)]
        7579  +
#[allow(clippy::too_many_arguments)]
        7580  +
#[::pyo3::pymethods]
        7581  +
impl InvalidGreeting {
        7582  +
    #[new]
        7583  +
    pub fn new(message: ::std::option::Option<::std::string::String>) -> Self {
        7584  +
        Self { message }
        7585  +
    }
        7586  +
    fn __repr__(&self) -> String {
        7587  +
        format!("{self:?}")
        7588  +
    }
        7589  +
    fn __str__(&self) -> String {
        7590  +
        format!("{self:?}")
        7591  +
    }
        7592  +
}
        7593  +
impl InvalidGreeting {
        7594  +
    /// Returns the error message.
        7595  +
    pub fn message(&self) -> ::std::option::Option<&str> {
        7596  +
        self.message.as_deref()
        7597  +
    }
        7598  +
    #[doc(hidden)]
        7599  +
    /// Returns the error name.
        7600  +
    pub fn name(&self) -> &'static str {
        7601  +
        "InvalidGreeting"
        7602  +
    }
        7603  +
}
        7604  +
impl ::std::fmt::Display for InvalidGreeting {
        7605  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7606  +
        ::std::write!(f, "InvalidGreeting")?;
        7607  +
        if let ::std::option::Option::Some(inner_1) = &self.message {
        7608  +
            {
        7609  +
                ::std::write!(f, ": {inner_1}")?;
        7610  +
            }
        7611  +
        }
        7612  +
        Ok(())
        7613  +
    }
        7614  +
}
        7615  +
impl ::std::error::Error for InvalidGreeting {}
        7616  +
impl InvalidGreeting {
        7617  +
    /// Creates a new builder-style object to manufacture [`InvalidGreeting`](crate::error::InvalidGreeting).
        7618  +
    pub fn builder() -> crate::error::invalid_greeting::Builder {
        7619  +
        crate::error::invalid_greeting::Builder::default()
        7620  +
    }
        7621  +
}
        7622  +
        7623  +
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
        7624  +
/// :param header typing.Optional\[str\]:
        7625  +
/// :param top_level typing.Optional\[str\]:
        7626  +
/// :param nested typing.Optional\[rest_json.model.ComplexNestedErrorData\]:
        7627  +
/// :rtype None:
        7628  +
/// This error is thrown when a request is invalid.
        7629  +
#[derive(
        7630  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
        7631  +
)]
        7632  +
pub struct ComplexError {
        7633  +
    #[pyo3(get, set)]
        7634  +
    /// :type typing.Optional\[str\]:
        7635  +
    #[allow(missing_docs)] // documentation missing in model
        7636  +
    pub header: ::std::option::Option<::std::string::String>,
        7637  +
    #[pyo3(get, set)]
        7638  +
    /// :type typing.Optional\[str\]:
        7639  +
    #[allow(missing_docs)] // documentation missing in model
        7640  +
    pub top_level: ::std::option::Option<::std::string::String>,
        7641  +
    #[pyo3(get, set)]
        7642  +
    /// :type typing.Optional\[rest_json.model.ComplexNestedErrorData\]:
        7643  +
    #[allow(missing_docs)] // documentation missing in model
        7644  +
    pub nested: ::std::option::Option<crate::model::ComplexNestedErrorData>,
        7645  +
}
        7646  +
impl ComplexError {
        7647  +
    #[allow(missing_docs)] // documentation missing in model
        7648  +
    pub fn header(&self) -> ::std::option::Option<&str> {
        7649  +
        self.header.as_deref()
        7650  +
    }
        7651  +
    #[allow(missing_docs)] // documentation missing in model
        7652  +
    pub fn top_level(&self) -> ::std::option::Option<&str> {
        7653  +
        self.top_level.as_deref()
        7654  +
    }
        7655  +
    #[allow(missing_docs)] // documentation missing in model
        7656  +
    pub fn nested(&self) -> ::std::option::Option<&crate::model::ComplexNestedErrorData> {
        7657  +
        self.nested.as_ref()
        7658  +
    }
        7659  +
}
        7660  +
#[allow(clippy::new_without_default)]
        7661  +
#[allow(clippy::too_many_arguments)]
        7662  +
#[::pyo3::pymethods]
        7663  +
impl ComplexError {
        7664  +
    #[new]
        7665  +
    pub fn new(
        7666  +
        header: ::std::option::Option<::std::string::String>,
        7667  +
        top_level: ::std::option::Option<::std::string::String>,
        7668  +
        nested: ::std::option::Option<crate::model::ComplexNestedErrorData>,
        7669  +
    ) -> Self {
        7670  +
        Self {
        7671  +
            header,
        7672  +
            top_level,
        7673  +
            nested,
        7674  +
        }
        7675  +
    }
        7676  +
    fn __repr__(&self) -> String {
        7677  +
        format!("{self:?}")
        7678  +
    }
        7679  +
    fn __str__(&self) -> String {
        7680  +
        format!("{self:?}")
        7681  +
    }
        7682  +
}
        7683  +
impl ComplexError {
        7684  +
    #[doc(hidden)]
        7685  +
    /// Returns the error name.
        7686  +
    pub fn name(&self) -> &'static str {
        7687  +
        "ComplexError"
        7688  +
    }
        7689  +
}
        7690  +
impl ::std::fmt::Display for ComplexError {
        7691  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7692  +
        ::std::write!(f, "ComplexError")?;
        7693  +
        Ok(())
        7694  +
    }
        7695  +
}
        7696  +
impl ::std::error::Error for ComplexError {}
        7697  +
impl ComplexError {
        7698  +
    /// Creates a new builder-style object to manufacture [`ComplexError`](crate::error::ComplexError).
        7699  +
    pub fn builder() -> crate::error::complex_error::Builder {
        7700  +
        crate::error::complex_error::Builder::default()
        7701  +
    }
        7702  +
}
        7703  +
        7704  +
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
        7705  +
/// :rtype None:
        7706  +
/// This error has test cases that test some of the dark corners of Amazon service framework history. It should only be implemented by clients.
        7707  +
#[derive(
        7708  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
        7709  +
)]
        7710  +
pub struct FooError {}
        7711  +
#[allow(clippy::new_without_default)]
        7712  +
#[allow(clippy::too_many_arguments)]
        7713  +
#[::pyo3::pymethods]
        7714  +
impl FooError {
        7715  +
    #[new]
        7716  +
    pub fn new() -> Self {
        7717  +
        Self {}
        7718  +
    }
        7719  +
    fn __repr__(&self) -> String {
        7720  +
        format!("{self:?}")
        7721  +
    }
        7722  +
    fn __str__(&self) -> String {
        7723  +
        format!("{self:?}")
        7724  +
    }
        7725  +
}
        7726  +
impl FooError {
        7727  +
    #[doc(hidden)]
        7728  +
    /// Returns the error name.
        7729  +
    pub fn name(&self) -> &'static str {
        7730  +
        "FooError"
        7731  +
    }
        7732  +
}
        7733  +
impl ::std::fmt::Display for FooError {
        7734  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7735  +
        ::std::write!(f, "FooError")?;
        7736  +
        Ok(())
        7737  +
    }
        7738  +
}
        7739  +
impl ::std::error::Error for FooError {}
        7740  +
impl FooError {
        7741  +
    /// Creates a new builder-style object to manufacture [`FooError`](crate::error::FooError).
        7742  +
    pub fn builder() -> crate::error::foo_error::Builder {
        7743  +
        crate::error::foo_error::Builder::default()
        7744  +
    }
        7745  +
}
        7746  +
        7747  +
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
        7748  +
/// :param message typing.Optional\[str\]:
        7749  +
/// :rtype None:
        7750  +
#[allow(missing_docs)] // documentation missing in model
        7751  +
#[derive(
        7752  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
        7753  +
)]
        7754  +
pub struct ErrorEvent {
        7755  +
    #[pyo3(get, set)]
        7756  +
    /// :type typing.Optional\[str\]:
        7757  +
    #[allow(missing_docs)] // documentation missing in model
        7758  +
    pub message: ::std::option::Option<::std::string::String>,
        7759  +
}
        7760  +
#[allow(clippy::new_without_default)]
        7761  +
#[allow(clippy::too_many_arguments)]
        7762  +
#[::pyo3::pymethods]
        7763  +
impl ErrorEvent {
        7764  +
    #[new]
        7765  +
    pub fn new(message: ::std::option::Option<::std::string::String>) -> Self {
        7766  +
        Self { message }
        7767  +
    }
        7768  +
    fn __repr__(&self) -> String {
        7769  +
        format!("{self:?}")
        7770  +
    }
        7771  +
    fn __str__(&self) -> String {
        7772  +
        format!("{self:?}")
        7773  +
    }
        7774  +
}
        7775  +
impl ErrorEvent {
        7776  +
    /// Returns the error message.
        7777  +
    pub fn message(&self) -> ::std::option::Option<&str> {
        7778  +
        self.message.as_deref()
 6875   7779   
    }
 6876         -
    /// Returns the error name string by matching the correct variant.
        7780  +
    #[doc(hidden)]
        7781  +
    /// Returns the error name.
 6877   7782   
    pub fn name(&self) -> &'static str {
 6878         -
        match &self {
 6879         -
            EmptyInputAndEmptyOutputError::InternalServerError(_inner) => _inner.name(),
 6880         -
        }
        7783  +
        "ErrorEvent"
 6881   7784   
    }
 6882   7785   
}
 6883         -
impl ::std::error::Error for EmptyInputAndEmptyOutputError {
 6884         -
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6885         -
        match &self {
 6886         -
            EmptyInputAndEmptyOutputError::InternalServerError(_inner) => Some(_inner),
        7786  +
impl ::std::fmt::Display for ErrorEvent {
        7787  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7788  +
        ::std::write!(f, "ErrorEvent")?;
        7789  +
        if let ::std::option::Option::Some(inner_2) = &self.message {
        7790  +
            {
        7791  +
                ::std::write!(f, ": {inner_2}")?;
        7792  +
            }
 6887   7793   
        }
        7794  +
        Ok(())
 6888   7795   
    }
 6889   7796   
}
 6890         -
impl ::std::convert::From<crate::error::InternalServerError>
 6891         -
    for crate::error::EmptyInputAndEmptyOutputError
 6892         -
{
 6893         -
    fn from(
 6894         -
        variant: crate::error::InternalServerError,
 6895         -
    ) -> crate::error::EmptyInputAndEmptyOutputError {
 6896         -
        Self::InternalServerError(variant)
 6897         -
    }
        7797  +
impl ::std::error::Error for ErrorEvent {}
        7798  +
impl crate::constrained::Constrained for crate::error::ErrorEvent {
        7799  +
    type Unconstrained = crate::error::error_event_internal::Builder;
 6898   7800   
}
 6899         -
 6900         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::EmptyInputAndEmptyOutputError {
 6901         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::EmptyInputAndEmptyOutputError {
 6902         -
        ::pyo3::Python::with_gil(|py| {
 6903         -
            let error = variant.value(py);
 6904         -
 6905         -
            crate::error::InternalServerError {
 6906         -
                message: error.to_string(),
 6907         -
            }
 6908         -
            .into()
 6909         -
        })
        7801  +
impl ErrorEvent {
        7802  +
    /// Creates a new builder-style object to manufacture [`ErrorEvent`](crate::error::ErrorEvent).
        7803  +
    pub fn builder() -> crate::error::error_event::Builder {
        7804  +
        crate::error::error_event::Builder::default()
 6910   7805   
    }
 6911   7806   
}
 6912   7807   
 6913         -
/// Error type for the `NoInputAndOutput` operation.
 6914         -
/// Each variant represents an error that can occur for the `NoInputAndOutput` operation.
 6915         -
#[derive(::std::fmt::Debug)]
 6916         -
pub enum NoInputAndOutputError {
        7808  +
#[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
        7809  +
/// :param message typing.Optional\[str\]:
        7810  +
/// :rtype None:
        7811  +
#[allow(missing_docs)] // documentation missing in model
        7812  +
#[derive(
        7813  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
        7814  +
)]
        7815  +
pub struct ServiceUnavailableError {
        7816  +
    #[pyo3(get, set)]
        7817  +
    /// :type typing.Optional\[str\]:
 6917   7818   
    #[allow(missing_docs)] // documentation missing in model
 6918         -
    InternalServerError(crate::error::InternalServerError),
        7819  +
    pub message: ::std::option::Option<::std::string::String>,
 6919   7820   
}
 6920         -
impl ::std::fmt::Display for NoInputAndOutputError {
 6921         -
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6922         -
        match &self {
 6923         -
            NoInputAndOutputError::InternalServerError(_inner) => _inner.fmt(f),
 6924         -
        }
        7821  +
#[allow(clippy::new_without_default)]
        7822  +
#[allow(clippy::too_many_arguments)]
        7823  +
#[::pyo3::pymethods]
        7824  +
impl ServiceUnavailableError {
        7825  +
    #[new]
        7826  +
    pub fn new(message: ::std::option::Option<::std::string::String>) -> Self {
        7827  +
        Self { message }
        7828  +
    }
        7829  +
    fn __repr__(&self) -> String {
        7830  +
        format!("{self:?}")
        7831  +
    }
        7832  +
    fn __str__(&self) -> String {
        7833  +
        format!("{self:?}")
 6925   7834   
    }
 6926   7835   
}
 6927         -
impl NoInputAndOutputError {
 6928         -
    /// Returns `true` if the error kind is `NoInputAndOutputError::InternalServerError`.
 6929         -
    pub fn is_internal_server_error(&self) -> bool {
 6930         -
        matches!(&self, NoInputAndOutputError::InternalServerError(_))
        7836  +
impl ServiceUnavailableError {
        7837  +
    /// Returns the error message.
        7838  +
    pub fn message(&self) -> ::std::option::Option<&str> {
        7839  +
        self.message.as_deref()
 6931   7840   
    }
 6932         -
    /// Returns the error name string by matching the correct variant.
        7841  +
    #[doc(hidden)]
        7842  +
    /// Returns the error name.
 6933   7843   
    pub fn name(&self) -> &'static str {
 6934         -
        match &self {
 6935         -
            NoInputAndOutputError::InternalServerError(_inner) => _inner.name(),
 6936         -
        }
        7844  +
        "ServiceUnavailableError"
 6937   7845   
    }
 6938   7846   
}
 6939         -
impl ::std::error::Error for NoInputAndOutputError {
 6940         -
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6941         -
        match &self {
 6942         -
            NoInputAndOutputError::InternalServerError(_inner) => Some(_inner),
        7847  +
impl ::std::fmt::Display for ServiceUnavailableError {
        7848  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        7849  +
        ::std::write!(f, "ServiceUnavailableError")?;
        7850  +
        if let ::std::option::Option::Some(inner_3) = &self.message {
        7851  +
            {
        7852  +
                ::std::write!(f, ": {inner_3}")?;
        7853  +
            }
 6943   7854   
        }
        7855  +
        Ok(())
 6944   7856   
    }
 6945   7857   
}
 6946         -
impl ::std::convert::From<crate::error::InternalServerError>
 6947         -
    for crate::error::NoInputAndOutputError
 6948         -
{
 6949         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::NoInputAndOutputError {
 6950         -
        Self::InternalServerError(variant)
 6951         -
    }
 6952         -
}
 6953         -
 6954         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NoInputAndOutputError {
 6955         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::NoInputAndOutputError {
 6956         -
        ::pyo3::Python::with_gil(|py| {
 6957         -
            let error = variant.value(py);
 6958         -
 6959         -
            crate::error::InternalServerError {
 6960         -
                message: error.to_string(),
 6961         -
            }
 6962         -
            .into()
 6963         -
        })
        7858  +
impl ::std::error::Error for ServiceUnavailableError {}
        7859  +
impl ServiceUnavailableError {
        7860  +
    /// Creates a new builder-style object to manufacture [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
        7861  +
    pub fn builder() -> crate::error::service_unavailable_error::Builder {
        7862  +
        crate::error::service_unavailable_error::Builder::default()
 6964   7863   
    }
 6965   7864   
}
 6966   7865   
 6967         -
/// Error type for the `NoInputAndNoOutput` operation.
 6968         -
/// Each variant represents an error that can occur for the `NoInputAndNoOutput` operation.
        7866  +
/// Error type for the `EventStream` operation.
        7867  +
/// Each variant represents an error that can occur for the `EventStream` operation.
 6969   7868   
#[derive(::std::fmt::Debug)]
 6970         -
pub enum NoInputAndNoOutputError {
        7869  +
pub enum EventStreamError {
 6971   7870   
    #[allow(missing_docs)] // documentation missing in model
 6972         -
    InternalServerError(crate::error::InternalServerError),
        7871  +
    ErrorEvent(crate::error::ErrorEvent),
 6973   7872   
}
 6974         -
impl ::std::fmt::Display for NoInputAndNoOutputError {
        7873  +
impl ::std::fmt::Display for EventStreamError {
 6975   7874   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 6976   7875   
        match &self {
 6977         -
            NoInputAndNoOutputError::InternalServerError(_inner) => _inner.fmt(f),
        7876  +
            EventStreamError::ErrorEvent(_inner) => _inner.fmt(f),
 6978   7877   
        }
 6979   7878   
    }
 6980   7879   
}
 6981         -
impl NoInputAndNoOutputError {
 6982         -
    /// Returns `true` if the error kind is `NoInputAndNoOutputError::InternalServerError`.
 6983         -
    pub fn is_internal_server_error(&self) -> bool {
 6984         -
        matches!(&self, NoInputAndNoOutputError::InternalServerError(_))
        7880  +
impl EventStreamError {
        7881  +
    /// Returns `true` if the error kind is `EventStreamError::ErrorEvent`.
        7882  +
    pub fn is_error_event(&self) -> bool {
        7883  +
        matches!(&self, EventStreamError::ErrorEvent(_))
 6985   7884   
    }
 6986   7885   
    /// Returns the error name string by matching the correct variant.
 6987   7886   
    pub fn name(&self) -> &'static str {
 6988   7887   
        match &self {
 6989         -
            NoInputAndNoOutputError::InternalServerError(_inner) => _inner.name(),
        7888  +
            EventStreamError::ErrorEvent(_inner) => _inner.name(),
 6990   7889   
        }
 6991   7890   
    }
 6992   7891   
}
 6993         -
impl ::std::error::Error for NoInputAndNoOutputError {
        7892  +
impl ::std::error::Error for EventStreamError {
 6994   7893   
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
 6995   7894   
        match &self {
 6996         -
            NoInputAndNoOutputError::InternalServerError(_inner) => Some(_inner),
        7895  +
            EventStreamError::ErrorEvent(_inner) => Some(_inner),
 6997   7896   
        }
 6998   7897   
    }
 6999   7898   
}
 7000         -
impl ::std::convert::From<crate::error::InternalServerError>
 7001         -
    for crate::error::NoInputAndNoOutputError
 7002         -
{
 7003         -
    fn from(variant: crate::error::InternalServerError) -> crate::error::NoInputAndNoOutputError {
 7004         -
        Self::InternalServerError(variant)
        7899  +
impl ::std::convert::From<crate::error::ErrorEvent> for crate::error::EventStreamError {
        7900  +
    fn from(variant: crate::error::ErrorEvent) -> crate::error::EventStreamError {
        7901  +
        Self::ErrorEvent(variant)
 7005   7902   
    }
 7006   7903   
}
 7007         -
 7008         -
impl ::std::convert::From<::pyo3::PyErr> for crate::error::NoInputAndNoOutputError {
 7009         -
    fn from(variant: ::pyo3::PyErr) -> crate::error::NoInputAndNoOutputError {
        7904  +
impl<'source> ::pyo3::FromPyObject<'source> for EventStreamError {
        7905  +
    fn extract(obj: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
        7906  +
        if let Ok(it) = obj.extract::<crate::error::ErrorEvent>() {
        7907  +
            return Ok(Self::ErrorEvent(it));
        7908  +
        }
        7909  +
        Err(::pyo3::exceptions::PyTypeError::new_err(format!(
        7910  +
            "failed to extract 'EventStreamError' from '{}'",
        7911  +
            obj
        7912  +
        )))
        7913  +
    }
        7914  +
}
        7915  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for EventStreamError {
        7916  +
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
        7917  +
        match self {
        7918  +
            Self::ErrorEvent(it) => match ::pyo3::Py::new(py, it) {
        7919  +
                Ok(it) => it.into_py(py),
        7920  +
                Err(err) => err.into_py(py),
        7921  +
            },
        7922  +
        }
        7923  +
    }
        7924  +
}
        7925  +
impl ::std::convert::From<EventStreamError> for ::pyo3::PyErr {
        7926  +
    fn from(err: EventStreamError) -> ::pyo3::PyErr {
 7010   7927   
        ::pyo3::Python::with_gil(|py| {
 7011         -
            let error = variant.value(py);
 7012         -
 7013         -
            crate::error::InternalServerError {
 7014         -
                message: error.to_string(),
 7015         -
            }
 7016         -
            .into()
        7928  +
            let py_err = ::pyo3::IntoPy::into_py(err, py);
        7929  +
            ::pyo3::PyErr::from_value(py_err.as_ref(py))
 7017   7930   
        })
 7018   7931   
    }
 7019   7932   
}
 7020   7933   
/// See [`InternalServerError`](crate::error::InternalServerError).
 7021   7934   
pub mod internal_server_error {
 7022   7935   
 7023   7936   
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
 7024   7937   
    /// Holds one variant for each of the ways the builder can fail.
 7025   7938   
    #[allow(clippy::enum_variant_names)]
 7026   7939   
    pub enum ConstraintViolation {
@@ -7105,8018 +7232,8238 @@
 7125   8038   
        fn build_enforcing_required_and_enum_traits(
 7126   8039   
            self,
 7127   8040   
        ) -> Result<crate::error::ValidationException, ConstraintViolation> {
 7128   8041   
            Ok(crate::error::ValidationException {
 7129   8042   
                message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
 7130   8043   
                field_list: self.field_list,
 7131   8044   
            })
 7132   8045   
        }
 7133   8046   
    }
 7134   8047   
}
 7135         -
/// See [`FooError`](crate::error::FooError).
 7136         -
pub mod foo_error {
        8048  +
/// See [`InvalidGreeting`](crate::error::InvalidGreeting).
        8049  +
pub mod invalid_greeting {
 7137   8050   
 7138         -
    impl ::std::convert::From<Builder> for crate::error::FooError {
        8051  +
    impl ::std::convert::From<Builder> for crate::error::InvalidGreeting {
 7139   8052   
        fn from(builder: Builder) -> Self {
 7140   8053   
            builder.build()
 7141   8054   
        }
 7142   8055   
    }
 7143         -
    /// A builder for [`FooError`](crate::error::FooError).
        8056  +
    /// A builder for [`InvalidGreeting`](crate::error::InvalidGreeting).
 7144   8057   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 7145         -
    pub struct Builder {}
        8058  +
    pub struct Builder {
        8059  +
        pub(crate) message: ::std::option::Option<::std::string::String>,
        8060  +
    }
 7146   8061   
    impl Builder {
 7147         -
        /// Consumes the builder and constructs a [`FooError`](crate::error::FooError).
 7148         -
        pub fn build(self) -> crate::error::FooError {
        8062  +
        #[allow(missing_docs)] // documentation missing in model
        8063  +
        pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        8064  +
            self.message = input;
        8065  +
            self
        8066  +
        }
        8067  +
        /// Consumes the builder and constructs a [`InvalidGreeting`](crate::error::InvalidGreeting).
        8068  +
        pub fn build(self) -> crate::error::InvalidGreeting {
 7149   8069   
            self.build_enforcing_required_and_enum_traits()
 7150   8070   
        }
 7151         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::FooError {
 7152         -
            crate::error::FooError {}
        8071  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::InvalidGreeting {
        8072  +
            crate::error::InvalidGreeting {
        8073  +
                message: self.message,
        8074  +
            }
 7153   8075   
        }
 7154   8076   
    }
 7155   8077   
}
 7156   8078   
/// See [`ComplexError`](crate::error::ComplexError).
 7157   8079   
pub mod complex_error {
 7158   8080   
 7159   8081   
    impl ::std::convert::From<Builder> for crate::error::ComplexError {
 7160   8082   
        fn from(builder: Builder) -> Self {
 7161   8083   
            builder.build()
 7162   8084   
        }
 7163   8085   
    }
 7164   8086   
    /// A builder for [`ComplexError`](crate::error::ComplexError).
 7165   8087   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 7166   8088   
    pub struct Builder {
 7167   8089   
        pub(crate) header: ::std::option::Option<::std::string::String>,
 7168   8090   
        pub(crate) top_level: ::std::option::Option<::std::string::String>,
 7169   8091   
        pub(crate) nested: ::std::option::Option<crate::model::ComplexNestedErrorData>,
 7170   8092   
    }
 7171   8093   
    impl Builder {
 7172   8094   
        #[allow(missing_docs)] // documentation missing in model
 7173   8095   
        pub fn header(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
 7174   8096   
            self.header = input;
 7175   8097   
            self
 7176   8098   
        }
 7177   8099   
        #[allow(missing_docs)] // documentation missing in model
 7178   8100   
        pub fn top_level(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
 7179   8101   
            self.top_level = input;
 7180   8102   
            self
 7181   8103   
        }
 7182   8104   
        #[allow(missing_docs)] // documentation missing in model
 7183   8105   
        pub fn nested(
 7184   8106   
            mut self,
 7185   8107   
            input: ::std::option::Option<crate::model::ComplexNestedErrorData>,
 7186   8108   
        ) -> Self {
 7187   8109   
            self.nested = input;
 7188   8110   
            self
 7189   8111   
        }
 7190   8112   
        /// Consumes the builder and constructs a [`ComplexError`](crate::error::ComplexError).
 7191   8113   
        pub fn build(self) -> crate::error::ComplexError {
 7192   8114   
            self.build_enforcing_required_and_enum_traits()
 7193   8115   
        }
 7194   8116   
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::ComplexError {
 7195   8117   
            crate::error::ComplexError {
 7196   8118   
                header: self.header,
 7197   8119   
                top_level: self.top_level,
 7198   8120   
                nested: self.nested,
 7199   8121   
            }
 7200   8122   
        }
 7201   8123   
    }
 7202   8124   
}
 7203         -
/// See [`InvalidGreeting`](crate::error::InvalidGreeting).
 7204         -
pub mod invalid_greeting {
        8125  +
/// See [`FooError`](crate::error::FooError).
        8126  +
pub mod foo_error {
 7205   8127   
 7206         -
    impl ::std::convert::From<Builder> for crate::error::InvalidGreeting {
        8128  +
    impl ::std::convert::From<Builder> for crate::error::FooError {
 7207   8129   
        fn from(builder: Builder) -> Self {
 7208   8130   
            builder.build()
 7209   8131   
        }
 7210   8132   
    }
 7211         -
    /// A builder for [`InvalidGreeting`](crate::error::InvalidGreeting).
        8133  +
    /// A builder for [`FooError`](crate::error::FooError).
        8134  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        8135  +
    pub struct Builder {}
        8136  +
    impl Builder {
        8137  +
        /// Consumes the builder and constructs a [`FooError`](crate::error::FooError).
        8138  +
        pub fn build(self) -> crate::error::FooError {
        8139  +
            self.build_enforcing_required_and_enum_traits()
        8140  +
        }
        8141  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::FooError {
        8142  +
            crate::error::FooError {}
        8143  +
        }
        8144  +
    }
        8145  +
}
        8146  +
/// See [`ErrorEvent`](crate::error::ErrorEvent).
        8147  +
pub(crate) mod error_event_internal {
        8148  +
        8149  +
    impl ::std::convert::From<Builder> for crate::error::ErrorEvent {
        8150  +
        fn from(builder: Builder) -> Self {
        8151  +
            builder.build()
        8152  +
        }
        8153  +
    }
        8154  +
    /// A builder for [`ErrorEvent`](crate::error::ErrorEvent).
        8155  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        8156  +
    pub(crate) struct Builder {
        8157  +
        pub(crate) message: ::std::option::Option<::std::string::String>,
        8158  +
    }
        8159  +
    impl Builder {
        8160  +
        #[allow(missing_docs)] // documentation missing in model
        8161  +
        pub(crate) fn set_message(
        8162  +
            mut self,
        8163  +
            input: Option<impl ::std::convert::Into<::std::string::String>>,
        8164  +
        ) -> Self {
        8165  +
            self.message = input.map(|v| v.into());
        8166  +
            self
        8167  +
        }
        8168  +
        /// Consumes the builder and constructs a [`ErrorEvent`](crate::error::ErrorEvent).
        8169  +
        pub fn build(self) -> crate::error::ErrorEvent {
        8170  +
            self.build_enforcing_all_constraints()
        8171  +
        }
        8172  +
        fn build_enforcing_all_constraints(self) -> crate::error::ErrorEvent {
        8173  +
            crate::error::ErrorEvent {
        8174  +
                message: self.message,
        8175  +
            }
        8176  +
        }
        8177  +
    }
        8178  +
}
        8179  +
/// See [`ErrorEvent`](crate::error::ErrorEvent).
        8180  +
pub mod error_event {
        8181  +
        8182  +
    impl ::std::convert::From<Builder> for crate::error::ErrorEvent {
        8183  +
        fn from(builder: Builder) -> Self {
        8184  +
            builder.build()
        8185  +
        }
        8186  +
    }
        8187  +
    /// A builder for [`ErrorEvent`](crate::error::ErrorEvent).
 7212   8188   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 7213   8189   
    pub struct Builder {
 7214   8190   
        pub(crate) message: ::std::option::Option<::std::string::String>,
 7215   8191   
    }
 7216   8192   
    impl Builder {
 7217   8193   
        #[allow(missing_docs)] // documentation missing in model
 7218   8194   
        pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
 7219   8195   
            self.message = input;
 7220   8196   
            self
 7221   8197   
        }
 7222         -
        /// Consumes the builder and constructs a [`InvalidGreeting`](crate::error::InvalidGreeting).
 7223         -
        pub fn build(self) -> crate::error::InvalidGreeting {
        8198  +
        /// Consumes the builder and constructs a [`ErrorEvent`](crate::error::ErrorEvent).
        8199  +
        pub fn build(self) -> crate::error::ErrorEvent {
 7224   8200   
            self.build_enforcing_required_and_enum_traits()
 7225   8201   
        }
 7226         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::InvalidGreeting {
 7227         -
            crate::error::InvalidGreeting {
        8202  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::ErrorEvent {
        8203  +
            crate::error::ErrorEvent {
        8204  +
                message: self.message,
        8205  +
            }
        8206  +
        }
        8207  +
    }
        8208  +
}
        8209  +
/// See [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
        8210  +
pub mod service_unavailable_error {
        8211  +
        8212  +
    impl ::std::convert::From<Builder> for crate::error::ServiceUnavailableError {
        8213  +
        fn from(builder: Builder) -> Self {
        8214  +
            builder.build()
        8215  +
        }
        8216  +
    }
        8217  +
    /// A builder for [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
        8218  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        8219  +
    pub struct Builder {
        8220  +
        pub(crate) message: ::std::option::Option<::std::string::String>,
        8221  +
    }
        8222  +
    impl Builder {
        8223  +
        #[allow(missing_docs)] // documentation missing in model
        8224  +
        pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        8225  +
            self.message = input;
        8226  +
            self
        8227  +
        }
        8228  +
        /// Consumes the builder and constructs a [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
        8229  +
        pub fn build(self) -> crate::error::ServiceUnavailableError {
        8230  +
            self.build_enforcing_required_and_enum_traits()
        8231  +
        }
        8232  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::ServiceUnavailableError {
        8233  +
            crate::error::ServiceUnavailableError {
 7228   8234   
                message: self.message,
 7229   8235   
            }
 7230   8236   
        }
 7231   8237   
    }
 7232   8238   
}