Server Test

Server Test

rev. 03e6e47f15dfd569240d570d98975ebba692c405 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types-http0x/rust-server-codegen/src/error.rs

@@ -0,1 +0,1132 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/// Error type for the `EventStreamsOperation` operation.
           3  +
/// Each variant represents an error that can occur for the `EventStreamsOperation` operation.
           4  +
#[derive(::std::fmt::Debug)]
           5  +
pub enum EventStreamsOperationError {
           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),
           8  +
    #[allow(missing_docs)] // documentation missing in model
           9  +
    EventStreamErrorMessage(crate::error::EventStreamErrorMessage),
          10  +
}
          11  +
impl ::std::fmt::Display for EventStreamsOperationError {
          12  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
          13  +
        match &self {
          14  +
            EventStreamsOperationError::ValidationException(_inner) => _inner.fmt(f),
          15  +
            EventStreamsOperationError::EventStreamErrorMessage(_inner) => _inner.fmt(f),
          16  +
        }
          17  +
    }
          18  +
}
          19  +
impl EventStreamsOperationError {
          20  +
    /// Returns `true` if the error kind is `EventStreamsOperationError::ValidationException`.
          21  +
    pub fn is_validation_exception(&self) -> bool {
          22  +
        matches!(&self, EventStreamsOperationError::ValidationException(_))
          23  +
    }
          24  +
    /// Returns `true` if the error kind is `EventStreamsOperationError::EventStreamErrorMessage`.
          25  +
    pub fn is_event_stream_error_message(&self) -> bool {
          26  +
        matches!(
          27  +
            &self,
          28  +
            EventStreamsOperationError::EventStreamErrorMessage(_)
          29  +
        )
          30  +
    }
          31  +
    /// Returns the error name string by matching the correct variant.
          32  +
    pub fn name(&self) -> &'static str {
          33  +
        match &self {
          34  +
            EventStreamsOperationError::ValidationException(_inner) => _inner.name(),
          35  +
            EventStreamsOperationError::EventStreamErrorMessage(_inner) => _inner.name(),
          36  +
        }
          37  +
    }
          38  +
}
          39  +
impl ::std::error::Error for EventStreamsOperationError {
          40  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
          41  +
        match &self {
          42  +
            EventStreamsOperationError::ValidationException(_inner) => Some(_inner),
          43  +
            EventStreamsOperationError::EventStreamErrorMessage(_inner) => Some(_inner),
          44  +
        }
          45  +
    }
          46  +
}
          47  +
impl ::std::convert::From<crate::error::ValidationException>
          48  +
    for crate::error::EventStreamsOperationError
          49  +
{
          50  +
    fn from(
          51  +
        variant: crate::error::ValidationException,
          52  +
    ) -> crate::error::EventStreamsOperationError {
          53  +
        Self::ValidationException(variant)
          54  +
    }
          55  +
}
          56  +
impl ::std::convert::From<crate::error::EventStreamErrorMessage>
          57  +
    for crate::error::EventStreamsOperationError
          58  +
{
          59  +
    fn from(
          60  +
        variant: crate::error::EventStreamErrorMessage,
          61  +
    ) -> crate::error::EventStreamsOperationError {
          62  +
        Self::EventStreamErrorMessage(variant)
          63  +
    }
          64  +
}
          65  +
          66  +
#[allow(missing_docs)] // documentation missing in model
          67  +
#[derive(
          68  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
          69  +
)]
          70  +
pub struct EventStreamErrorMessage {
          71  +
    #[allow(missing_docs)] // documentation missing in model
          72  +
    pub message_content: ::std::option::Option<::std::string::String>,
          73  +
}
          74  +
impl EventStreamErrorMessage {
          75  +
    #[allow(missing_docs)] // documentation missing in model
          76  +
    pub fn message_content(&self) -> ::std::option::Option<&str> {
          77  +
        self.message_content.as_deref()
          78  +
    }
          79  +
}
          80  +
impl EventStreamErrorMessage {
          81  +
    #[doc(hidden)]
          82  +
    /// Returns the error name.
          83  +
    pub fn name(&self) -> &'static str {
          84  +
        "EventStreamErrorMessage"
          85  +
    }
          86  +
}
          87  +
impl ::std::fmt::Display for EventStreamErrorMessage {
          88  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
          89  +
        ::std::write!(f, "EventStreamErrorMessage")?;
          90  +
        Ok(())
          91  +
    }
          92  +
}
          93  +
impl ::std::error::Error for EventStreamErrorMessage {}
          94  +
impl crate::constrained::Constrained for crate::error::EventStreamErrorMessage {
          95  +
    type Unconstrained = crate::error::event_stream_error_message_internal::Builder;
          96  +
}
          97  +
impl EventStreamErrorMessage {
          98  +
    /// Creates a new builder-style object to manufacture [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).
          99  +
    pub fn builder() -> crate::error::event_stream_error_message::Builder {
         100  +
        crate::error::event_stream_error_message::Builder::default()
         101  +
    }
         102  +
}
         103  +
         104  +
/// 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.
         105  +
#[derive(
         106  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         107  +
)]
         108  +
pub struct ValidationException {
         109  +
    /// A summary of the validation failure.
         110  +
    pub message: ::std::string::String,
         111  +
    /// 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.
         112  +
    pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
         113  +
}
         114  +
impl ValidationException {
         115  +
    /// 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.
         116  +
    pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
         117  +
        self.field_list.as_deref()
         118  +
    }
         119  +
}
         120  +
impl ValidationException {
         121  +
    /// Returns the error message.
         122  +
    pub fn message(&self) -> &str {
         123  +
        &self.message
         124  +
    }
         125  +
    #[doc(hidden)]
         126  +
    /// Returns the error name.
         127  +
    pub fn name(&self) -> &'static str {
         128  +
        "ValidationException"
         129  +
    }
         130  +
}
         131  +
impl ::std::fmt::Display for ValidationException {
         132  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         133  +
        ::std::write!(f, "ValidationException")?;
         134  +
        {
         135  +
            ::std::write!(f, ": {}", &self.message)?;
         136  +
        }
         137  +
        Ok(())
         138  +
    }
         139  +
}
         140  +
impl ::std::error::Error for ValidationException {}
         141  +
impl ValidationException {
         142  +
    /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
         143  +
    pub fn builder() -> crate::error::validation_exception::Builder {
         144  +
        crate::error::validation_exception::Builder::default()
         145  +
    }
         146  +
}
         147  +
         148  +
/// Error type for the `Event` operation.
         149  +
/// Each variant represents an error that can occur for the `Event` operation.
         150  +
#[derive(::std::fmt::Debug)]
         151  +
pub enum EventError {
         152  +
    #[allow(missing_docs)] // documentation missing in model
         153  +
    EventStreamErrorMessage(crate::error::EventStreamErrorMessage),
         154  +
}
         155  +
impl ::std::fmt::Display for EventError {
         156  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         157  +
        match &self {
         158  +
            EventError::EventStreamErrorMessage(_inner) => _inner.fmt(f),
         159  +
        }
         160  +
    }
         161  +
}
         162  +
impl EventError {
         163  +
    /// Returns `true` if the error kind is `EventError::EventStreamErrorMessage`.
         164  +
    pub fn is_event_stream_error_message(&self) -> bool {
         165  +
        matches!(&self, EventError::EventStreamErrorMessage(_))
         166  +
    }
         167  +
    /// Returns the error name string by matching the correct variant.
         168  +
    pub fn name(&self) -> &'static str {
         169  +
        match &self {
         170  +
            EventError::EventStreamErrorMessage(_inner) => _inner.name(),
         171  +
        }
         172  +
    }
         173  +
}
         174  +
impl ::std::error::Error for EventError {
         175  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         176  +
        match &self {
         177  +
            EventError::EventStreamErrorMessage(_inner) => Some(_inner),
         178  +
        }
         179  +
    }
         180  +
}
         181  +
impl ::std::convert::From<crate::error::EventStreamErrorMessage> for crate::error::EventError {
         182  +
    fn from(variant: crate::error::EventStreamErrorMessage) -> crate::error::EventError {
         183  +
        Self::EventStreamErrorMessage(variant)
         184  +
    }
         185  +
}
         186  +
         187  +
/// Error type for the `QueryParamsTargetingMapOfEnumStringOperation` operation.
         188  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfEnumStringOperation` operation.
         189  +
#[derive(::std::fmt::Debug)]
         190  +
pub enum QueryParamsTargetingMapOfEnumStringOperationError {
         191  +
    /// 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.
         192  +
    ValidationException(crate::error::ValidationException),
         193  +
}
         194  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfEnumStringOperationError {
         195  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         196  +
        match &self {
         197  +
            QueryParamsTargetingMapOfEnumStringOperationError::ValidationException(_inner) => {
         198  +
                _inner.fmt(f)
         199  +
            }
         200  +
        }
         201  +
    }
         202  +
}
         203  +
impl QueryParamsTargetingMapOfEnumStringOperationError {
         204  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfEnumStringOperationError::ValidationException`.
         205  +
    pub fn is_validation_exception(&self) -> bool {
         206  +
        matches!(
         207  +
            &self,
         208  +
            QueryParamsTargetingMapOfEnumStringOperationError::ValidationException(_)
         209  +
        )
         210  +
    }
         211  +
    /// Returns the error name string by matching the correct variant.
         212  +
    pub fn name(&self) -> &'static str {
         213  +
        match &self {
         214  +
            QueryParamsTargetingMapOfEnumStringOperationError::ValidationException(_inner) => {
         215  +
                _inner.name()
         216  +
            }
         217  +
        }
         218  +
    }
         219  +
}
         220  +
impl ::std::error::Error for QueryParamsTargetingMapOfEnumStringOperationError {
         221  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         222  +
        match &self {
         223  +
            QueryParamsTargetingMapOfEnumStringOperationError::ValidationException(_inner) => {
         224  +
                Some(_inner)
         225  +
            }
         226  +
        }
         227  +
    }
         228  +
}
         229  +
impl ::std::convert::From<crate::error::ValidationException>
         230  +
    for crate::error::QueryParamsTargetingMapOfEnumStringOperationError
         231  +
{
         232  +
    fn from(
         233  +
        variant: crate::error::ValidationException,
         234  +
    ) -> crate::error::QueryParamsTargetingMapOfEnumStringOperationError {
         235  +
        Self::ValidationException(variant)
         236  +
    }
         237  +
}
         238  +
         239  +
/// Error type for the `HttpPrefixHeadersTargetingLengthMapOperation` operation.
         240  +
/// Each variant represents an error that can occur for the `HttpPrefixHeadersTargetingLengthMapOperation` operation.
         241  +
#[derive(::std::fmt::Debug)]
         242  +
pub enum HttpPrefixHeadersTargetingLengthMapOperationError {
         243  +
    /// 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.
         244  +
    ValidationException(crate::error::ValidationException),
         245  +
}
         246  +
impl ::std::fmt::Display for HttpPrefixHeadersTargetingLengthMapOperationError {
         247  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         248  +
        match &self {
         249  +
            HttpPrefixHeadersTargetingLengthMapOperationError::ValidationException(_inner) => {
         250  +
                _inner.fmt(f)
         251  +
            }
         252  +
        }
         253  +
    }
         254  +
}
         255  +
impl HttpPrefixHeadersTargetingLengthMapOperationError {
         256  +
    /// Returns `true` if the error kind is `HttpPrefixHeadersTargetingLengthMapOperationError::ValidationException`.
         257  +
    pub fn is_validation_exception(&self) -> bool {
         258  +
        matches!(
         259  +
            &self,
         260  +
            HttpPrefixHeadersTargetingLengthMapOperationError::ValidationException(_)
         261  +
        )
         262  +
    }
         263  +
    /// Returns the error name string by matching the correct variant.
         264  +
    pub fn name(&self) -> &'static str {
         265  +
        match &self {
         266  +
            HttpPrefixHeadersTargetingLengthMapOperationError::ValidationException(_inner) => {
         267  +
                _inner.name()
         268  +
            }
         269  +
        }
         270  +
    }
         271  +
}
         272  +
impl ::std::error::Error for HttpPrefixHeadersTargetingLengthMapOperationError {
         273  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         274  +
        match &self {
         275  +
            HttpPrefixHeadersTargetingLengthMapOperationError::ValidationException(_inner) => {
         276  +
                Some(_inner)
         277  +
            }
         278  +
        }
         279  +
    }
         280  +
}
         281  +
impl ::std::convert::From<crate::error::ValidationException>
         282  +
    for crate::error::HttpPrefixHeadersTargetingLengthMapOperationError
         283  +
{
         284  +
    fn from(
         285  +
        variant: crate::error::ValidationException,
         286  +
    ) -> crate::error::HttpPrefixHeadersTargetingLengthMapOperationError {
         287  +
        Self::ValidationException(variant)
         288  +
    }
         289  +
}
         290  +
         291  +
/// Error type for the `QueryParamsTargetingMapOfListOfLengthPatternStringOperation` operation.
         292  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfListOfLengthPatternStringOperation` operation.
         293  +
#[derive(::std::fmt::Debug)]
         294  +
pub enum QueryParamsTargetingMapOfListOfLengthPatternStringOperationError {
         295  +
    /// 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.
         296  +
    ValidationException(crate::error::ValidationException),
         297  +
}
         298  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfListOfLengthPatternStringOperationError {
         299  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         300  +
        match &self {
         301  +
            QueryParamsTargetingMapOfListOfLengthPatternStringOperationError::ValidationException(_inner) =>
         302  +
            _inner.fmt(f)
         303  +
            ,
         304  +
        }
         305  +
    }
         306  +
}
         307  +
impl QueryParamsTargetingMapOfListOfLengthPatternStringOperationError {
         308  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfListOfLengthPatternStringOperationError::ValidationException`.
         309  +
    pub fn is_validation_exception(&self) -> bool {
         310  +
        matches!(
         311  +
            &self,
         312  +
            QueryParamsTargetingMapOfListOfLengthPatternStringOperationError::ValidationException(
         313  +
                _
         314  +
            )
         315  +
        )
         316  +
    }
         317  +
    /// Returns the error name string by matching the correct variant.
         318  +
    pub fn name(&self) -> &'static str {
         319  +
        match &self {
         320  +
            QueryParamsTargetingMapOfListOfLengthPatternStringOperationError::ValidationException(_inner) =>
         321  +
            _inner.name()
         322  +
            ,
         323  +
        }
         324  +
    }
         325  +
}
         326  +
impl ::std::error::Error for QueryParamsTargetingMapOfListOfLengthPatternStringOperationError {
         327  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         328  +
        match &self {
         329  +
            QueryParamsTargetingMapOfListOfLengthPatternStringOperationError::ValidationException(_inner) =>
         330  +
            Some(_inner)
         331  +
            ,
         332  +
        }
         333  +
    }
         334  +
}
         335  +
impl ::std::convert::From<crate::error::ValidationException>
         336  +
    for crate::error::QueryParamsTargetingMapOfListOfLengthPatternStringOperationError
         337  +
{
         338  +
    fn from(
         339  +
        variant: crate::error::ValidationException,
         340  +
    ) -> crate::error::QueryParamsTargetingMapOfListOfLengthPatternStringOperationError {
         341  +
        Self::ValidationException(variant)
         342  +
    }
         343  +
}
         344  +
         345  +
/// Error type for the `QueryParamsTargetingMapOfLengthPatternStringOperation` operation.
         346  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfLengthPatternStringOperation` operation.
         347  +
#[derive(::std::fmt::Debug)]
         348  +
pub enum QueryParamsTargetingMapOfLengthPatternStringOperationError {
         349  +
    /// 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.
         350  +
    ValidationException(crate::error::ValidationException),
         351  +
}
         352  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfLengthPatternStringOperationError {
         353  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         354  +
        match &self {
         355  +
            QueryParamsTargetingMapOfLengthPatternStringOperationError::ValidationException(
         356  +
                _inner,
         357  +
            ) => _inner.fmt(f),
         358  +
        }
         359  +
    }
         360  +
}
         361  +
impl QueryParamsTargetingMapOfLengthPatternStringOperationError {
         362  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfLengthPatternStringOperationError::ValidationException`.
         363  +
    pub fn is_validation_exception(&self) -> bool {
         364  +
        matches!(
         365  +
            &self,
         366  +
            QueryParamsTargetingMapOfLengthPatternStringOperationError::ValidationException(_)
         367  +
        )
         368  +
    }
         369  +
    /// Returns the error name string by matching the correct variant.
         370  +
    pub fn name(&self) -> &'static str {
         371  +
        match &self {
         372  +
            QueryParamsTargetingMapOfLengthPatternStringOperationError::ValidationException(
         373  +
                _inner,
         374  +
            ) => _inner.name(),
         375  +
        }
         376  +
    }
         377  +
}
         378  +
impl ::std::error::Error for QueryParamsTargetingMapOfLengthPatternStringOperationError {
         379  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         380  +
        match &self {
         381  +
            QueryParamsTargetingMapOfLengthPatternStringOperationError::ValidationException(
         382  +
                _inner,
         383  +
            ) => Some(_inner),
         384  +
        }
         385  +
    }
         386  +
}
         387  +
impl ::std::convert::From<crate::error::ValidationException>
         388  +
    for crate::error::QueryParamsTargetingMapOfLengthPatternStringOperationError
         389  +
{
         390  +
    fn from(
         391  +
        variant: crate::error::ValidationException,
         392  +
    ) -> crate::error::QueryParamsTargetingMapOfLengthPatternStringOperationError {
         393  +
        Self::ValidationException(variant)
         394  +
    }
         395  +
}
         396  +
         397  +
/// Error type for the `QueryParamsTargetingMapOfListOfPatternStringOperation` operation.
         398  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfListOfPatternStringOperation` operation.
         399  +
#[derive(::std::fmt::Debug)]
         400  +
pub enum QueryParamsTargetingMapOfListOfPatternStringOperationError {
         401  +
    /// 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.
         402  +
    ValidationException(crate::error::ValidationException),
         403  +
}
         404  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfListOfPatternStringOperationError {
         405  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         406  +
        match &self {
         407  +
            QueryParamsTargetingMapOfListOfPatternStringOperationError::ValidationException(
         408  +
                _inner,
         409  +
            ) => _inner.fmt(f),
         410  +
        }
         411  +
    }
         412  +
}
         413  +
impl QueryParamsTargetingMapOfListOfPatternStringOperationError {
         414  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfListOfPatternStringOperationError::ValidationException`.
         415  +
    pub fn is_validation_exception(&self) -> bool {
         416  +
        matches!(
         417  +
            &self,
         418  +
            QueryParamsTargetingMapOfListOfPatternStringOperationError::ValidationException(_)
         419  +
        )
         420  +
    }
         421  +
    /// Returns the error name string by matching the correct variant.
         422  +
    pub fn name(&self) -> &'static str {
         423  +
        match &self {
         424  +
            QueryParamsTargetingMapOfListOfPatternStringOperationError::ValidationException(
         425  +
                _inner,
         426  +
            ) => _inner.name(),
         427  +
        }
         428  +
    }
         429  +
}
         430  +
impl ::std::error::Error for QueryParamsTargetingMapOfListOfPatternStringOperationError {
         431  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         432  +
        match &self {
         433  +
            QueryParamsTargetingMapOfListOfPatternStringOperationError::ValidationException(
         434  +
                _inner,
         435  +
            ) => Some(_inner),
         436  +
        }
         437  +
    }
         438  +
}
         439  +
impl ::std::convert::From<crate::error::ValidationException>
         440  +
    for crate::error::QueryParamsTargetingMapOfListOfPatternStringOperationError
         441  +
{
         442  +
    fn from(
         443  +
        variant: crate::error::ValidationException,
         444  +
    ) -> crate::error::QueryParamsTargetingMapOfListOfPatternStringOperationError {
         445  +
        Self::ValidationException(variant)
         446  +
    }
         447  +
}
         448  +
         449  +
/// Error type for the `QueryParamsTargetingMapOfPatternStringOperation` operation.
         450  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfPatternStringOperation` operation.
         451  +
#[derive(::std::fmt::Debug)]
         452  +
pub enum QueryParamsTargetingMapOfPatternStringOperationError {
         453  +
    /// 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.
         454  +
    ValidationException(crate::error::ValidationException),
         455  +
}
         456  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfPatternStringOperationError {
         457  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         458  +
        match &self {
         459  +
            QueryParamsTargetingMapOfPatternStringOperationError::ValidationException(_inner) => {
         460  +
                _inner.fmt(f)
         461  +
            }
         462  +
        }
         463  +
    }
         464  +
}
         465  +
impl QueryParamsTargetingMapOfPatternStringOperationError {
         466  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfPatternStringOperationError::ValidationException`.
         467  +
    pub fn is_validation_exception(&self) -> bool {
         468  +
        matches!(
         469  +
            &self,
         470  +
            QueryParamsTargetingMapOfPatternStringOperationError::ValidationException(_)
         471  +
        )
         472  +
    }
         473  +
    /// Returns the error name string by matching the correct variant.
         474  +
    pub fn name(&self) -> &'static str {
         475  +
        match &self {
         476  +
            QueryParamsTargetingMapOfPatternStringOperationError::ValidationException(_inner) => {
         477  +
                _inner.name()
         478  +
            }
         479  +
        }
         480  +
    }
         481  +
}
         482  +
impl ::std::error::Error for QueryParamsTargetingMapOfPatternStringOperationError {
         483  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         484  +
        match &self {
         485  +
            QueryParamsTargetingMapOfPatternStringOperationError::ValidationException(_inner) => {
         486  +
                Some(_inner)
         487  +
            }
         488  +
        }
         489  +
    }
         490  +
}
         491  +
impl ::std::convert::From<crate::error::ValidationException>
         492  +
    for crate::error::QueryParamsTargetingMapOfPatternStringOperationError
         493  +
{
         494  +
    fn from(
         495  +
        variant: crate::error::ValidationException,
         496  +
    ) -> crate::error::QueryParamsTargetingMapOfPatternStringOperationError {
         497  +
        Self::ValidationException(variant)
         498  +
    }
         499  +
}
         500  +
         501  +
/// Error type for the `QueryParamsTargetingMapOfListOfEnumStringOperation` operation.
         502  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfListOfEnumStringOperation` operation.
         503  +
#[derive(::std::fmt::Debug)]
         504  +
pub enum QueryParamsTargetingMapOfListOfEnumStringOperationError {
         505  +
    /// 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.
         506  +
    ValidationException(crate::error::ValidationException),
         507  +
}
         508  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfListOfEnumStringOperationError {
         509  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         510  +
        match &self {
         511  +
            QueryParamsTargetingMapOfListOfEnumStringOperationError::ValidationException(
         512  +
                _inner,
         513  +
            ) => _inner.fmt(f),
         514  +
        }
         515  +
    }
         516  +
}
         517  +
impl QueryParamsTargetingMapOfListOfEnumStringOperationError {
         518  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfListOfEnumStringOperationError::ValidationException`.
         519  +
    pub fn is_validation_exception(&self) -> bool {
         520  +
        matches!(
         521  +
            &self,
         522  +
            QueryParamsTargetingMapOfListOfEnumStringOperationError::ValidationException(_)
         523  +
        )
         524  +
    }
         525  +
    /// Returns the error name string by matching the correct variant.
         526  +
    pub fn name(&self) -> &'static str {
         527  +
        match &self {
         528  +
            QueryParamsTargetingMapOfListOfEnumStringOperationError::ValidationException(
         529  +
                _inner,
         530  +
            ) => _inner.name(),
         531  +
        }
         532  +
    }
         533  +
}
         534  +
impl ::std::error::Error for QueryParamsTargetingMapOfListOfEnumStringOperationError {
         535  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         536  +
        match &self {
         537  +
            QueryParamsTargetingMapOfListOfEnumStringOperationError::ValidationException(
         538  +
                _inner,
         539  +
            ) => Some(_inner),
         540  +
        }
         541  +
    }
         542  +
}
         543  +
impl ::std::convert::From<crate::error::ValidationException>
         544  +
    for crate::error::QueryParamsTargetingMapOfListOfEnumStringOperationError
         545  +
{
         546  +
    fn from(
         547  +
        variant: crate::error::ValidationException,
         548  +
    ) -> crate::error::QueryParamsTargetingMapOfListOfEnumStringOperationError {
         549  +
        Self::ValidationException(variant)
         550  +
    }
         551  +
}
         552  +
         553  +
/// Error type for the `QueryParamsTargetingMapOfLengthListOfPatternStringOperation` operation.
         554  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfLengthListOfPatternStringOperation` operation.
         555  +
#[derive(::std::fmt::Debug)]
         556  +
pub enum QueryParamsTargetingMapOfLengthListOfPatternStringOperationError {
         557  +
    /// 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.
         558  +
    ValidationException(crate::error::ValidationException),
         559  +
}
         560  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfLengthListOfPatternStringOperationError {
         561  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         562  +
        match &self {
         563  +
            QueryParamsTargetingMapOfLengthListOfPatternStringOperationError::ValidationException(_inner) =>
         564  +
            _inner.fmt(f)
         565  +
            ,
         566  +
        }
         567  +
    }
         568  +
}
         569  +
impl QueryParamsTargetingMapOfLengthListOfPatternStringOperationError {
         570  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfLengthListOfPatternStringOperationError::ValidationException`.
         571  +
    pub fn is_validation_exception(&self) -> bool {
         572  +
        matches!(
         573  +
            &self,
         574  +
            QueryParamsTargetingMapOfLengthListOfPatternStringOperationError::ValidationException(
         575  +
                _
         576  +
            )
         577  +
        )
         578  +
    }
         579  +
    /// Returns the error name string by matching the correct variant.
         580  +
    pub fn name(&self) -> &'static str {
         581  +
        match &self {
         582  +
            QueryParamsTargetingMapOfLengthListOfPatternStringOperationError::ValidationException(_inner) =>
         583  +
            _inner.name()
         584  +
            ,
         585  +
        }
         586  +
    }
         587  +
}
         588  +
impl ::std::error::Error for QueryParamsTargetingMapOfLengthListOfPatternStringOperationError {
         589  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         590  +
        match &self {
         591  +
            QueryParamsTargetingMapOfLengthListOfPatternStringOperationError::ValidationException(_inner) =>
         592  +
            Some(_inner)
         593  +
            ,
         594  +
        }
         595  +
    }
         596  +
}
         597  +
impl ::std::convert::From<crate::error::ValidationException>
         598  +
    for crate::error::QueryParamsTargetingMapOfLengthListOfPatternStringOperationError
         599  +
{
         600  +
    fn from(
         601  +
        variant: crate::error::ValidationException,
         602  +
    ) -> crate::error::QueryParamsTargetingMapOfLengthListOfPatternStringOperationError {
         603  +
        Self::ValidationException(variant)
         604  +
    }
         605  +
}
         606  +
         607  +
/// Error type for the `QueryParamsTargetingMapOfSetOfLengthStringOperation` operation.
         608  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfSetOfLengthStringOperation` operation.
         609  +
#[derive(::std::fmt::Debug)]
         610  +
pub enum QueryParamsTargetingMapOfSetOfLengthStringOperationError {
         611  +
    /// 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.
         612  +
    ValidationException(crate::error::ValidationException),
         613  +
}
         614  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfSetOfLengthStringOperationError {
         615  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         616  +
        match &self {
         617  +
            QueryParamsTargetingMapOfSetOfLengthStringOperationError::ValidationException(
         618  +
                _inner,
         619  +
            ) => _inner.fmt(f),
         620  +
        }
         621  +
    }
         622  +
}
         623  +
impl QueryParamsTargetingMapOfSetOfLengthStringOperationError {
         624  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfSetOfLengthStringOperationError::ValidationException`.
         625  +
    pub fn is_validation_exception(&self) -> bool {
         626  +
        matches!(
         627  +
            &self,
         628  +
            QueryParamsTargetingMapOfSetOfLengthStringOperationError::ValidationException(_)
         629  +
        )
         630  +
    }
         631  +
    /// Returns the error name string by matching the correct variant.
         632  +
    pub fn name(&self) -> &'static str {
         633  +
        match &self {
         634  +
            QueryParamsTargetingMapOfSetOfLengthStringOperationError::ValidationException(
         635  +
                _inner,
         636  +
            ) => _inner.name(),
         637  +
        }
         638  +
    }
         639  +
}
         640  +
impl ::std::error::Error for QueryParamsTargetingMapOfSetOfLengthStringOperationError {
         641  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         642  +
        match &self {
         643  +
            QueryParamsTargetingMapOfSetOfLengthStringOperationError::ValidationException(
         644  +
                _inner,
         645  +
            ) => Some(_inner),
         646  +
        }
         647  +
    }
         648  +
}
         649  +
impl ::std::convert::From<crate::error::ValidationException>
         650  +
    for crate::error::QueryParamsTargetingMapOfSetOfLengthStringOperationError
         651  +
{
         652  +
    fn from(
         653  +
        variant: crate::error::ValidationException,
         654  +
    ) -> crate::error::QueryParamsTargetingMapOfSetOfLengthStringOperationError {
         655  +
        Self::ValidationException(variant)
         656  +
    }
         657  +
}
         658  +
         659  +
/// Error type for the `QueryParamsTargetingMapOfListOfLengthStringOperation` operation.
         660  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfListOfLengthStringOperation` operation.
         661  +
#[derive(::std::fmt::Debug)]
         662  +
pub enum QueryParamsTargetingMapOfListOfLengthStringOperationError {
         663  +
    /// 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.
         664  +
    ValidationException(crate::error::ValidationException),
         665  +
}
         666  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfListOfLengthStringOperationError {
         667  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         668  +
        match &self {
         669  +
            QueryParamsTargetingMapOfListOfLengthStringOperationError::ValidationException(
         670  +
                _inner,
         671  +
            ) => _inner.fmt(f),
         672  +
        }
         673  +
    }
         674  +
}
         675  +
impl QueryParamsTargetingMapOfListOfLengthStringOperationError {
         676  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfListOfLengthStringOperationError::ValidationException`.
         677  +
    pub fn is_validation_exception(&self) -> bool {
         678  +
        matches!(
         679  +
            &self,
         680  +
            QueryParamsTargetingMapOfListOfLengthStringOperationError::ValidationException(_)
         681  +
        )
         682  +
    }
         683  +
    /// Returns the error name string by matching the correct variant.
         684  +
    pub fn name(&self) -> &'static str {
         685  +
        match &self {
         686  +
            QueryParamsTargetingMapOfListOfLengthStringOperationError::ValidationException(
         687  +
                _inner,
         688  +
            ) => _inner.name(),
         689  +
        }
         690  +
    }
         691  +
}
         692  +
impl ::std::error::Error for QueryParamsTargetingMapOfListOfLengthStringOperationError {
         693  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         694  +
        match &self {
         695  +
            QueryParamsTargetingMapOfListOfLengthStringOperationError::ValidationException(
         696  +
                _inner,
         697  +
            ) => Some(_inner),
         698  +
        }
         699  +
    }
         700  +
}
         701  +
impl ::std::convert::From<crate::error::ValidationException>
         702  +
    for crate::error::QueryParamsTargetingMapOfListOfLengthStringOperationError
         703  +
{
         704  +
    fn from(
         705  +
        variant: crate::error::ValidationException,
         706  +
    ) -> crate::error::QueryParamsTargetingMapOfListOfLengthStringOperationError {
         707  +
        Self::ValidationException(variant)
         708  +
    }
         709  +
}
         710  +
         711  +
/// Error type for the `QueryParamsTargetingMapOfLengthStringOperation` operation.
         712  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingMapOfLengthStringOperation` operation.
         713  +
#[derive(::std::fmt::Debug)]
         714  +
pub enum QueryParamsTargetingMapOfLengthStringOperationError {
         715  +
    /// 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.
         716  +
    ValidationException(crate::error::ValidationException),
         717  +
}
         718  +
impl ::std::fmt::Display for QueryParamsTargetingMapOfLengthStringOperationError {
         719  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         720  +
        match &self {
         721  +
            QueryParamsTargetingMapOfLengthStringOperationError::ValidationException(_inner) => {
         722  +
                _inner.fmt(f)
         723  +
            }
         724  +
        }
         725  +
    }
         726  +
}
         727  +
impl QueryParamsTargetingMapOfLengthStringOperationError {
         728  +
    /// Returns `true` if the error kind is `QueryParamsTargetingMapOfLengthStringOperationError::ValidationException`.
         729  +
    pub fn is_validation_exception(&self) -> bool {
         730  +
        matches!(
         731  +
            &self,
         732  +
            QueryParamsTargetingMapOfLengthStringOperationError::ValidationException(_)
         733  +
        )
         734  +
    }
         735  +
    /// Returns the error name string by matching the correct variant.
         736  +
    pub fn name(&self) -> &'static str {
         737  +
        match &self {
         738  +
            QueryParamsTargetingMapOfLengthStringOperationError::ValidationException(_inner) => {
         739  +
                _inner.name()
         740  +
            }
         741  +
        }
         742  +
    }
         743  +
}
         744  +
impl ::std::error::Error for QueryParamsTargetingMapOfLengthStringOperationError {
         745  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         746  +
        match &self {
         747  +
            QueryParamsTargetingMapOfLengthStringOperationError::ValidationException(_inner) => {
         748  +
                Some(_inner)
         749  +
            }
         750  +
        }
         751  +
    }
         752  +
}
         753  +
impl ::std::convert::From<crate::error::ValidationException>
         754  +
    for crate::error::QueryParamsTargetingMapOfLengthStringOperationError
         755  +
{
         756  +
    fn from(
         757  +
        variant: crate::error::ValidationException,
         758  +
    ) -> crate::error::QueryParamsTargetingMapOfLengthStringOperationError {
         759  +
        Self::ValidationException(variant)
         760  +
    }
         761  +
}
         762  +
         763  +
/// Error type for the `QueryParamsTargetingLengthMapOperation` operation.
         764  +
/// Each variant represents an error that can occur for the `QueryParamsTargetingLengthMapOperation` operation.
         765  +
#[derive(::std::fmt::Debug)]
         766  +
pub enum QueryParamsTargetingLengthMapOperationError {
         767  +
    /// 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.
         768  +
    ValidationException(crate::error::ValidationException),
         769  +
}
         770  +
impl ::std::fmt::Display for QueryParamsTargetingLengthMapOperationError {
         771  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         772  +
        match &self {
         773  +
            QueryParamsTargetingLengthMapOperationError::ValidationException(_inner) => {
         774  +
                _inner.fmt(f)
         775  +
            }
         776  +
        }
         777  +
    }
         778  +
}
         779  +
impl QueryParamsTargetingLengthMapOperationError {
         780  +
    /// Returns `true` if the error kind is `QueryParamsTargetingLengthMapOperationError::ValidationException`.
         781  +
    pub fn is_validation_exception(&self) -> bool {
         782  +
        matches!(
         783  +
            &self,
         784  +
            QueryParamsTargetingLengthMapOperationError::ValidationException(_)
         785  +
        )
         786  +
    }
         787  +
    /// Returns the error name string by matching the correct variant.
         788  +
    pub fn name(&self) -> &'static str {
         789  +
        match &self {
         790  +
            QueryParamsTargetingLengthMapOperationError::ValidationException(_inner) => {
         791  +
                _inner.name()
         792  +
            }
         793  +
        }
         794  +
    }
         795  +
}
         796  +
impl ::std::error::Error for QueryParamsTargetingLengthMapOperationError {
         797  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         798  +
        match &self {
         799  +
            QueryParamsTargetingLengthMapOperationError::ValidationException(_inner) => {
         800  +
                Some(_inner)
         801  +
            }
         802  +
        }
         803  +
    }
         804  +
}
         805  +
impl ::std::convert::From<crate::error::ValidationException>
         806  +
    for crate::error::QueryParamsTargetingLengthMapOperationError
         807  +
{
         808  +
    fn from(
         809  +
        variant: crate::error::ValidationException,
         810  +
    ) -> crate::error::QueryParamsTargetingLengthMapOperationError {
         811  +
        Self::ValidationException(variant)
         812  +
    }
         813  +
}
         814  +
         815  +
/// Error type for the `ConstrainedRecursiveShapesOperation` operation.
         816  +
/// Each variant represents an error that can occur for the `ConstrainedRecursiveShapesOperation` operation.
         817  +
#[derive(::std::fmt::Debug)]
         818  +
pub enum ConstrainedRecursiveShapesOperationError {
         819  +
    /// 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.
         820  +
    ValidationException(crate::error::ValidationException),
         821  +
}
         822  +
impl ::std::fmt::Display for ConstrainedRecursiveShapesOperationError {
         823  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         824  +
        match &self {
         825  +
            ConstrainedRecursiveShapesOperationError::ValidationException(_inner) => _inner.fmt(f),
         826  +
        }
         827  +
    }
         828  +
}
         829  +
impl ConstrainedRecursiveShapesOperationError {
         830  +
    /// Returns `true` if the error kind is `ConstrainedRecursiveShapesOperationError::ValidationException`.
         831  +
    pub fn is_validation_exception(&self) -> bool {
         832  +
        matches!(
         833  +
            &self,
         834  +
            ConstrainedRecursiveShapesOperationError::ValidationException(_)
         835  +
        )
         836  +
    }
         837  +
    /// Returns the error name string by matching the correct variant.
         838  +
    pub fn name(&self) -> &'static str {
         839  +
        match &self {
         840  +
            ConstrainedRecursiveShapesOperationError::ValidationException(_inner) => _inner.name(),
         841  +
        }
         842  +
    }
         843  +
}
         844  +
impl ::std::error::Error for ConstrainedRecursiveShapesOperationError {
         845  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         846  +
        match &self {
         847  +
            ConstrainedRecursiveShapesOperationError::ValidationException(_inner) => Some(_inner),
         848  +
        }
         849  +
    }
         850  +
}
         851  +
impl ::std::convert::From<crate::error::ValidationException>
         852  +
    for crate::error::ConstrainedRecursiveShapesOperationError
         853  +
{
         854  +
    fn from(
         855  +
        variant: crate::error::ValidationException,
         856  +
    ) -> crate::error::ConstrainedRecursiveShapesOperationError {
         857  +
        Self::ValidationException(variant)
         858  +
    }
         859  +
}
         860  +
         861  +
/// Error type for the `ConstrainedHttpPayloadBoundShapeOperation` operation.
         862  +
/// Each variant represents an error that can occur for the `ConstrainedHttpPayloadBoundShapeOperation` operation.
         863  +
#[derive(::std::fmt::Debug)]
         864  +
pub enum ConstrainedHttpPayloadBoundShapeOperationError {
         865  +
    /// 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.
         866  +
    ValidationException(crate::error::ValidationException),
         867  +
}
         868  +
impl ::std::fmt::Display for ConstrainedHttpPayloadBoundShapeOperationError {
         869  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         870  +
        match &self {
         871  +
            ConstrainedHttpPayloadBoundShapeOperationError::ValidationException(_inner) => {
         872  +
                _inner.fmt(f)
         873  +
            }
         874  +
        }
         875  +
    }
         876  +
}
         877  +
impl ConstrainedHttpPayloadBoundShapeOperationError {
         878  +
    /// Returns `true` if the error kind is `ConstrainedHttpPayloadBoundShapeOperationError::ValidationException`.
         879  +
    pub fn is_validation_exception(&self) -> bool {
         880  +
        matches!(
         881  +
            &self,
         882  +
            ConstrainedHttpPayloadBoundShapeOperationError::ValidationException(_)
         883  +
        )
         884  +
    }
         885  +
    /// Returns the error name string by matching the correct variant.
         886  +
    pub fn name(&self) -> &'static str {
         887  +
        match &self {
         888  +
            ConstrainedHttpPayloadBoundShapeOperationError::ValidationException(_inner) => {
         889  +
                _inner.name()
         890  +
            }
         891  +
        }
         892  +
    }
         893  +
}
         894  +
impl ::std::error::Error for ConstrainedHttpPayloadBoundShapeOperationError {
         895  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         896  +
        match &self {
         897  +
            ConstrainedHttpPayloadBoundShapeOperationError::ValidationException(_inner) => {
         898  +
                Some(_inner)
         899  +
            }
         900  +
        }
         901  +
    }
         902  +
}
         903  +
impl ::std::convert::From<crate::error::ValidationException>
         904  +
    for crate::error::ConstrainedHttpPayloadBoundShapeOperationError
         905  +
{
         906  +
    fn from(
         907  +
        variant: crate::error::ValidationException,
         908  +
    ) -> crate::error::ConstrainedHttpPayloadBoundShapeOperationError {
         909  +
        Self::ValidationException(variant)
         910  +
    }
         911  +
}
         912  +
         913  +
/// Error type for the `ConstrainedHttpBoundShapesOperation` operation.
         914  +
/// Each variant represents an error that can occur for the `ConstrainedHttpBoundShapesOperation` operation.
         915  +
#[derive(::std::fmt::Debug)]
         916  +
pub enum ConstrainedHttpBoundShapesOperationError {
         917  +
    /// 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.
         918  +
    ValidationException(crate::error::ValidationException),
         919  +
}
         920  +
impl ::std::fmt::Display for ConstrainedHttpBoundShapesOperationError {
         921  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         922  +
        match &self {
         923  +
            ConstrainedHttpBoundShapesOperationError::ValidationException(_inner) => _inner.fmt(f),
         924  +
        }
         925  +
    }
         926  +
}
         927  +
impl ConstrainedHttpBoundShapesOperationError {
         928  +
    /// Returns `true` if the error kind is `ConstrainedHttpBoundShapesOperationError::ValidationException`.
         929  +
    pub fn is_validation_exception(&self) -> bool {
         930  +
        matches!(
         931  +
            &self,
         932  +
            ConstrainedHttpBoundShapesOperationError::ValidationException(_)
         933  +
        )
         934  +
    }
         935  +
    /// Returns the error name string by matching the correct variant.
         936  +
    pub fn name(&self) -> &'static str {
         937  +
        match &self {
         938  +
            ConstrainedHttpBoundShapesOperationError::ValidationException(_inner) => _inner.name(),
         939  +
        }
         940  +
    }
         941  +
}
         942  +
impl ::std::error::Error for ConstrainedHttpBoundShapesOperationError {
         943  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         944  +
        match &self {
         945  +
            ConstrainedHttpBoundShapesOperationError::ValidationException(_inner) => Some(_inner),
         946  +
        }
         947  +
    }
         948  +
}
         949  +
impl ::std::convert::From<crate::error::ValidationException>
         950  +
    for crate::error::ConstrainedHttpBoundShapesOperationError
         951  +
{
         952  +
    fn from(
         953  +
        variant: crate::error::ValidationException,
         954  +
    ) -> crate::error::ConstrainedHttpBoundShapesOperationError {
         955  +
        Self::ValidationException(variant)
         956  +
    }
         957  +
}
         958  +
         959  +
/// Error type for the `ConstrainedShapesOperation` operation.
         960  +
/// Each variant represents an error that can occur for the `ConstrainedShapesOperation` operation.
         961  +
#[derive(::std::fmt::Debug)]
         962  +
pub enum ConstrainedShapesOperationError {
         963  +
    /// 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.
         964  +
    ValidationException(crate::error::ValidationException),
         965  +
}
         966  +
impl ::std::fmt::Display for ConstrainedShapesOperationError {
         967  +
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         968  +
        match &self {
         969  +
            ConstrainedShapesOperationError::ValidationException(_inner) => _inner.fmt(f),
         970  +
        }
         971  +
    }
         972  +
}
         973  +
impl ConstrainedShapesOperationError {
         974  +
    /// Returns `true` if the error kind is `ConstrainedShapesOperationError::ValidationException`.
         975  +
    pub fn is_validation_exception(&self) -> bool {
         976  +
        matches!(
         977  +
            &self,
         978  +
            ConstrainedShapesOperationError::ValidationException(_)
         979  +
        )
         980  +
    }
         981  +
    /// Returns the error name string by matching the correct variant.
         982  +
    pub fn name(&self) -> &'static str {
         983  +
        match &self {
         984  +
            ConstrainedShapesOperationError::ValidationException(_inner) => _inner.name(),
         985  +
        }
         986  +
    }
         987  +
}
         988  +
impl ::std::error::Error for ConstrainedShapesOperationError {
         989  +
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         990  +
        match &self {
         991  +
            ConstrainedShapesOperationError::ValidationException(_inner) => Some(_inner),
         992  +
        }
         993  +
    }
         994  +
}
         995  +
impl ::std::convert::From<crate::error::ValidationException>
         996  +
    for crate::error::ConstrainedShapesOperationError
         997  +
{
         998  +
    fn from(
         999  +
        variant: crate::error::ValidationException,
        1000  +
    ) -> crate::error::ConstrainedShapesOperationError {
        1001  +
        Self::ValidationException(variant)
        1002  +
    }
        1003  +
}
        1004  +
/// See [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).
        1005  +
pub(crate) mod event_stream_error_message_internal {
        1006  +
        1007  +
    impl ::std::convert::From<Builder> for crate::error::EventStreamErrorMessage {
        1008  +
        fn from(builder: Builder) -> Self {
        1009  +
            builder.build()
        1010  +
        }
        1011  +
    }
        1012  +
    /// A builder for [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).
        1013  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        1014  +
    pub(crate) struct Builder {
        1015  +
        pub(crate) message_content: ::std::option::Option<::std::string::String>,
        1016  +
    }
        1017  +
    impl Builder {
        1018  +
        #[allow(missing_docs)] // documentation missing in model
        1019  +
        pub(crate) fn set_message_content(
        1020  +
            mut self,
        1021  +
            input: Option<impl ::std::convert::Into<::std::string::String>>,
        1022  +
        ) -> Self {
        1023  +
            self.message_content = input.map(|v| v.into());
        1024  +
            self
        1025  +
        }
        1026  +
        /// Consumes the builder and constructs a [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).
        1027  +
        pub fn build(self) -> crate::error::EventStreamErrorMessage {
        1028  +
            self.build_enforcing_all_constraints()
        1029  +
        }
        1030  +
        fn build_enforcing_all_constraints(self) -> crate::error::EventStreamErrorMessage {
        1031  +
            crate::error::EventStreamErrorMessage {
        1032  +
                message_content: self.message_content,
        1033  +
            }
        1034  +
        }
        1035  +
    }
        1036  +
}
        1037  +
/// See [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).
        1038  +
pub mod event_stream_error_message {
        1039  +
        1040  +
    impl ::std::convert::From<Builder> for crate::error::EventStreamErrorMessage {
        1041  +
        fn from(builder: Builder) -> Self {
        1042  +
            builder.build()
        1043  +
        }
        1044  +
    }
        1045  +
    /// A builder for [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).
        1046  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        1047  +
    pub struct Builder {
        1048  +
        pub(crate) message_content: ::std::option::Option<::std::string::String>,
        1049  +
    }
        1050  +
    impl Builder {
        1051  +
        #[allow(missing_docs)] // documentation missing in model
        1052  +
        pub fn message_content(
        1053  +
            mut self,
        1054  +
            input: ::std::option::Option<::std::string::String>,
        1055  +
        ) -> Self {
        1056  +
            self.message_content = input;
        1057  +
            self
        1058  +
        }
        1059  +
        /// Consumes the builder and constructs a [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).
        1060  +
        pub fn build(self) -> crate::error::EventStreamErrorMessage {
        1061  +
            self.build_enforcing_required_and_enum_traits()
        1062  +
        }
        1063  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::error::EventStreamErrorMessage {
        1064  +
            crate::error::EventStreamErrorMessage {
        1065  +
                message_content: self.message_content,
        1066  +
            }
        1067  +
        }
        1068  +
    }
        1069  +
}
        1070  +
/// See [`ValidationException`](crate::error::ValidationException).
        1071  +
pub mod validation_exception {
        1072  +
        1073  +
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
        1074  +
    /// Holds one variant for each of the ways the builder can fail.
        1075  +
    #[allow(clippy::enum_variant_names)]
        1076  +
    pub enum ConstraintViolation {
        1077  +
        /// `message` was not provided but it is required when building `ValidationException`.
        1078  +
        MissingMessage,
        1079  +
    }
        1080  +
    impl ::std::fmt::Display for ConstraintViolation {
        1081  +
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        1082  +
            match self {
        1083  +
                ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationException`"),
        1084  +
            }
        1085  +
        }
        1086  +
    }
        1087  +
    impl ::std::error::Error for ConstraintViolation {}
        1088  +
    impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {
        1089  +
        type Error = ConstraintViolation;
        1090  +
        1091  +
        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
        1092  +
            builder.build()
        1093  +
        }
        1094  +
    }
        1095  +
    /// A builder for [`ValidationException`](crate::error::ValidationException).
        1096  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        1097  +
    pub struct Builder {
        1098  +
        pub(crate) message: ::std::option::Option<::std::string::String>,
        1099  +
        pub(crate) field_list:
        1100  +
            ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
        1101  +
    }
        1102  +
    impl Builder {
        1103  +
        /// A summary of the validation failure.
        1104  +
        pub fn message(mut self, input: ::std::string::String) -> Self {
        1105  +
            self.message = Some(input);
        1106  +
            self
        1107  +
        }
        1108  +
        /// 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.
        1109  +
        pub fn field_list(
        1110  +
            mut self,
        1111  +
            input: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
        1112  +
        ) -> Self {
        1113  +
            self.field_list = input;
        1114  +
            self
        1115  +
        }
        1116  +
        /// Consumes the builder and constructs a [`ValidationException`](crate::error::ValidationException).
        1117  +
        ///
        1118  +
        /// The builder fails to construct a [`ValidationException`](crate::error::ValidationException) if you do not provide a value for all non-`Option`al members.
        1119  +
        ///
        1120  +
        pub fn build(self) -> Result<crate::error::ValidationException, ConstraintViolation> {
        1121  +
            self.build_enforcing_required_and_enum_traits()
        1122  +
        }
        1123  +
        fn build_enforcing_required_and_enum_traits(
        1124  +
            self,
        1125  +
        ) -> Result<crate::error::ValidationException, ConstraintViolation> {
        1126  +
            Ok(crate::error::ValidationException {
        1127  +
                message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
        1128  +
                field_list: self.field_list,
        1129  +
            })
        1130  +
        }
        1131  +
    }
        1132  +
}