// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// 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.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ValidationError {
    /// A summary of the validation failure.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// 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.
    #[doc(hidden)]
    pub field_list: std::option::Option<std::vec::Vec<crate::model::ValidationExceptionField>>,
}
impl ValidationError {
    /// 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.
    pub fn field_list(&self) -> std::option::Option<&[crate::model::ValidationExceptionField]> {
        self.field_list.as_deref()
    }
}
impl ValidationError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ValidationError [ValidationException]")?;
        if let Some(inner_1) = &self.message {
            {
                write!(f, ": {}", inner_1)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for ValidationError {}
/// See [`ValidationError`](crate::error::ValidationError).
pub mod validation_error {

    /// A builder for [`ValidationError`](crate::error::ValidationError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) field_list:
            std::option::Option<std::vec::Vec<crate::model::ValidationExceptionField>>,
    }
    impl Builder {
        /// A summary of the validation failure.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// A summary of the validation failure.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Appends an item to `field_list`.
        ///
        /// To override the contents of this collection use [`set_field_list`](Self::set_field_list).
        ///
        /// 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.
        pub fn field_list(mut self, input: crate::model::ValidationExceptionField) -> Self {
            let mut v = self.field_list.unwrap_or_default();
            v.push(input);
            self.field_list = Some(v);
            self
        }
        /// 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.
        pub fn set_field_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ValidationExceptionField>>,
        ) -> Self {
            self.field_list = input;
            self
        }
        /// Consumes the builder and constructs a [`ValidationError`](crate::error::ValidationError).
        pub fn build(self) -> crate::error::ValidationError {
            crate::error::ValidationError {
                message: self.message,
                field_list: self.field_list,
            }
        }
    }
}
impl ValidationError {
    /// Creates a new builder-style object to manufacture [`ValidationError`](crate::error::ValidationError).
    pub fn builder() -> crate::error::validation_error::Builder {
        crate::error::validation_error::Builder::default()
    }
}

/// The server response when a payload is of an unsupported media type.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UnsupportedMediaTypeError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl UnsupportedMediaTypeError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl UnsupportedMediaTypeError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for UnsupportedMediaTypeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "UnsupportedMediaTypeError [UnsupportedMediaTypeException]"
        )?;
        if let Some(inner_2) = &self.message {
            {
                write!(f, ": {}", inner_2)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for UnsupportedMediaTypeError {}
/// See [`UnsupportedMediaTypeError`](crate::error::UnsupportedMediaTypeError).
pub mod unsupported_media_type_error {

    /// A builder for [`UnsupportedMediaTypeError`](crate::error::UnsupportedMediaTypeError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`UnsupportedMediaTypeError`](crate::error::UnsupportedMediaTypeError).
        pub fn build(self) -> crate::error::UnsupportedMediaTypeError {
            crate::error::UnsupportedMediaTypeError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl UnsupportedMediaTypeError {
    /// Creates a new builder-style object to manufacture [`UnsupportedMediaTypeError`](crate::error::UnsupportedMediaTypeError).
    pub fn builder() -> crate::error::unsupported_media_type_error::Builder {
        crate::error::unsupported_media_type_error::Builder::default()
    }
}

/// The Stedi account has not been granted permission for this particular service.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UnmappedError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl UnmappedError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl UnmappedError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for UnmappedError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "UnmappedError [UnmappedException]")?;
        if let Some(inner_3) = &self.message {
            {
                write!(f, ": {}", inner_3)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for UnmappedError {}
/// See [`UnmappedError`](crate::error::UnmappedError).
pub mod unmapped_error {

    /// A builder for [`UnmappedError`](crate::error::UnmappedError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`UnmappedError`](crate::error::UnmappedError).
        pub fn build(self) -> crate::error::UnmappedError {
            crate::error::UnmappedError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl UnmappedError {
    /// Creates a new builder-style object to manufacture [`UnmappedError`](crate::error::UnmappedError).
    pub fn builder() -> crate::error::unmapped_error::Builder {
        crate::error::unmapped_error::Builder::default()
    }
}

/// The server response when the operation specified could not be found.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UnknownOperationError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl UnknownOperationError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl UnknownOperationError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for UnknownOperationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "UnknownOperationError [UnknownOperationException]")?;
        if let Some(inner_4) = &self.message {
            {
                write!(f, ": {}", inner_4)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for UnknownOperationError {}
/// See [`UnknownOperationError`](crate::error::UnknownOperationError).
pub mod unknown_operation_error {

    /// A builder for [`UnknownOperationError`](crate::error::UnknownOperationError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`UnknownOperationError`](crate::error::UnknownOperationError).
        pub fn build(self) -> crate::error::UnknownOperationError {
            crate::error::UnknownOperationError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl UnknownOperationError {
    /// Creates a new builder-style object to manufacture [`UnknownOperationError`](crate::error::UnknownOperationError).
    pub fn builder() -> crate::error::unknown_operation_error::Builder {
        crate::error::unknown_operation_error::Builder::default()
    }
}

/// The server response when the authorizer failed to authenticate the caller.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UnauthorizedError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl UnauthorizedError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl UnauthorizedError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for UnauthorizedError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "UnauthorizedError [UnauthorizedException]")?;
        if let Some(inner_5) = &self.message {
            {
                write!(f, ": {}", inner_5)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for UnauthorizedError {}
/// See [`UnauthorizedError`](crate::error::UnauthorizedError).
pub mod unauthorized_error {

    /// A builder for [`UnauthorizedError`](crate::error::UnauthorizedError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`UnauthorizedError`](crate::error::UnauthorizedError).
        pub fn build(self) -> crate::error::UnauthorizedError {
            crate::error::UnauthorizedError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl UnauthorizedError {
    /// Creates a new builder-style object to manufacture [`UnauthorizedError`](crate::error::UnauthorizedError).
    pub fn builder() -> crate::error::unauthorized_error::Builder {
        crate::error::unauthorized_error::Builder::default()
    }
}

/// The server response when usage plan or account-level throttling limits exceeded.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ThrottlingError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl ThrottlingError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl ThrottlingError {
    /// Returns `Some(ErrorKind)` if the error is retryable. Otherwise, returns `None`.
    pub fn retryable_error_kind(&self) -> aws_smithy_types::retry::ErrorKind {
        aws_smithy_types::retry::ErrorKind::ThrottlingError
    }
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ThrottlingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ThrottlingError [ThrottlingException]")?;
        if let Some(inner_6) = &self.message {
            {
                write!(f, ": {}", inner_6)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for ThrottlingError {}
/// See [`ThrottlingError`](crate::error::ThrottlingError).
pub mod throttling_error {

    /// A builder for [`ThrottlingError`](crate::error::ThrottlingError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`ThrottlingError`](crate::error::ThrottlingError).
        pub fn build(self) -> crate::error::ThrottlingError {
            crate::error::ThrottlingError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl ThrottlingError {
    /// Creates a new builder-style object to manufacture [`ThrottlingError`](crate::error::ThrottlingError).
    pub fn builder() -> crate::error::throttling_error::Builder {
        crate::error::throttling_error::Builder::default()
    }
}

/// The server cannot handle the request due to technical reasons.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ServiceUnavailableError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl ServiceUnavailableError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl ServiceUnavailableError {
    /// Returns `Some(ErrorKind)` if the error is retryable. Otherwise, returns `None`.
    pub fn retryable_error_kind(&self) -> aws_smithy_types::retry::ErrorKind {
        aws_smithy_types::retry::ErrorKind::ServerError
    }
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ServiceUnavailableError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ServiceUnavailableError [ServiceUnavailableException]")?;
        if let Some(inner_7) = &self.message {
            {
                write!(f, ": {}", inner_7)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for ServiceUnavailableError {}
/// See [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
pub mod service_unavailable_error {

    /// A builder for [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
        pub fn build(self) -> crate::error::ServiceUnavailableError {
            crate::error::ServiceUnavailableError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl ServiceUnavailableError {
    /// Creates a new builder-style object to manufacture [`ServiceUnavailableError`](crate::error::ServiceUnavailableError).
    pub fn builder() -> crate::error::service_unavailable_error::Builder {
        crate::error::service_unavailable_error::Builder::default()
    }
}

/// The server response when attempting to serialize the request.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SerializationError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl SerializationError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl SerializationError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for SerializationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "SerializationError [SerializationException]")?;
        if let Some(inner_8) = &self.message {
            {
                write!(f, ": {}", inner_8)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for SerializationError {}
/// See [`SerializationError`](crate::error::SerializationError).
pub mod serialization_error {

    /// A builder for [`SerializationError`](crate::error::SerializationError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`SerializationError`](crate::error::SerializationError).
        pub fn build(self) -> crate::error::SerializationError {
            crate::error::SerializationError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl SerializationError {
    /// Creates a new builder-style object to manufacture [`SerializationError`](crate::error::SerializationError).
    pub fn builder() -> crate::error::serialization_error::Builder {
        crate::error::serialization_error::Builder::default()
    }
}

/// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceNotFoundError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl ResourceNotFoundError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl ResourceNotFoundError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ResourceNotFoundError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ResourceNotFoundError [ResourceNotFoundException]")?;
        if let Some(inner_9) = &self.message {
            {
                write!(f, ": {}", inner_9)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for ResourceNotFoundError {}
/// See [`ResourceNotFoundError`](crate::error::ResourceNotFoundError).
pub mod resource_not_found_error {

    /// A builder for [`ResourceNotFoundError`](crate::error::ResourceNotFoundError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`ResourceNotFoundError`](crate::error::ResourceNotFoundError).
        pub fn build(self) -> crate::error::ResourceNotFoundError {
            crate::error::ResourceNotFoundError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl ResourceNotFoundError {
    /// Creates a new builder-style object to manufacture [`ResourceNotFoundError`](crate::error::ResourceNotFoundError).
    pub fn builder() -> crate::error::resource_not_found_error::Builder {
        crate::error::resource_not_found_error::Builder::default()
    }
}

/// The server could not process the request because of conflict in the current state of the resource.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceConflictError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl ResourceConflictError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl ResourceConflictError {
    /// Returns `Some(ErrorKind)` if the error is retryable. Otherwise, returns `None`.
    pub fn retryable_error_kind(&self) -> aws_smithy_types::retry::ErrorKind {
        aws_smithy_types::retry::ErrorKind::ClientError
    }
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ResourceConflictError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ResourceConflictError [ResourceConflictException]")?;
        if let Some(inner_10) = &self.message {
            {
                write!(f, ": {}", inner_10)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for ResourceConflictError {}
/// See [`ResourceConflictError`](crate::error::ResourceConflictError).
pub mod resource_conflict_error {

    /// A builder for [`ResourceConflictError`](crate::error::ResourceConflictError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`ResourceConflictError`](crate::error::ResourceConflictError).
        pub fn build(self) -> crate::error::ResourceConflictError {
            crate::error::ResourceConflictError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl ResourceConflictError {
    /// Creates a new builder-style object to manufacture [`ResourceConflictError`](crate::error::ResourceConflictError).
    pub fn builder() -> crate::error::resource_conflict_error::Builder {
        crate::error::resource_conflict_error::Builder::default()
    }
}

/// The server response for the request too large error.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct RequestTooLargeError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl RequestTooLargeError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl RequestTooLargeError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for RequestTooLargeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "RequestTooLargeError [RequestTooLargeException]")?;
        if let Some(inner_11) = &self.message {
            {
                write!(f, ": {}", inner_11)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for RequestTooLargeError {}
/// See [`RequestTooLargeError`](crate::error::RequestTooLargeError).
pub mod request_too_large_error {

    /// A builder for [`RequestTooLargeError`](crate::error::RequestTooLargeError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`RequestTooLargeError`](crate::error::RequestTooLargeError).
        pub fn build(self) -> crate::error::RequestTooLargeError {
            crate::error::RequestTooLargeError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl RequestTooLargeError {
    /// Creates a new builder-style object to manufacture [`RequestTooLargeError`](crate::error::RequestTooLargeError).
    pub fn builder() -> crate::error::request_too_large_error::Builder {
        crate::error::request_too_large_error::Builder::default()
    }
}

/// The server response for the usage plan quota exceeded error.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct QuotaExceededError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl QuotaExceededError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl QuotaExceededError {
    /// Returns `Some(ErrorKind)` if the error is retryable. Otherwise, returns `None`.
    pub fn retryable_error_kind(&self) -> aws_smithy_types::retry::ErrorKind {
        aws_smithy_types::retry::ErrorKind::ThrottlingError
    }
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for QuotaExceededError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "QuotaExceededError [QuotaExceededException]")?;
        if let Some(inner_12) = &self.message {
            {
                write!(f, ": {}", inner_12)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for QuotaExceededError {}
/// See [`QuotaExceededError`](crate::error::QuotaExceededError).
pub mod quota_exceeded_error {

    /// A builder for [`QuotaExceededError`](crate::error::QuotaExceededError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`QuotaExceededError`](crate::error::QuotaExceededError).
        pub fn build(self) -> crate::error::QuotaExceededError {
            crate::error::QuotaExceededError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl QuotaExceededError {
    /// Creates a new builder-style object to manufacture [`QuotaExceededError`](crate::error::QuotaExceededError).
    pub fn builder() -> crate::error::quota_exceeded_error::Builder {
        crate::error::quota_exceeded_error::Builder::default()
    }
}

/// The server response when the requested resource is capable of generating only content not acceptable according to the Accept headers sent in the request.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct NotAcceptableError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl NotAcceptableError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl NotAcceptableError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for NotAcceptableError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "NotAcceptableError [NotAcceptableException]")?;
        if let Some(inner_13) = &self.message {
            {
                write!(f, ": {}", inner_13)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for NotAcceptableError {}
/// See [`NotAcceptableError`](crate::error::NotAcceptableError).
pub mod not_acceptable_error {

    /// A builder for [`NotAcceptableError`](crate::error::NotAcceptableError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`NotAcceptableError`](crate::error::NotAcceptableError).
        pub fn build(self) -> crate::error::NotAcceptableError {
            crate::error::NotAcceptableError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl NotAcceptableError {
    /// Creates a new builder-style object to manufacture [`NotAcceptableError`](crate::error::NotAcceptableError).
    pub fn builder() -> crate::error::not_acceptable_error::Builder {
        crate::error::not_acceptable_error::Builder::default()
    }
}

/// The server response when an unexpected error occurred while processing request.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct InternalFailureError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl InternalFailureError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl InternalFailureError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for InternalFailureError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "InternalFailureError [InternalFailureException]")?;
        if let Some(inner_14) = &self.message {
            {
                write!(f, ": {}", inner_14)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for InternalFailureError {}
/// See [`InternalFailureError`](crate::error::InternalFailureError).
pub mod internal_failure_error {

    /// A builder for [`InternalFailureError`](crate::error::InternalFailureError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`InternalFailureError`](crate::error::InternalFailureError).
        pub fn build(self) -> crate::error::InternalFailureError {
            crate::error::InternalFailureError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl InternalFailureError {
    /// Creates a new builder-style object to manufacture [`InternalFailureError`](crate::error::InternalFailureError).
    pub fn builder() -> crate::error::internal_failure_error::Builder {
        crate::error::internal_failure_error::Builder::default()
    }
}

/// The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GatewayTimeoutError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl GatewayTimeoutError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl GatewayTimeoutError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for GatewayTimeoutError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "GatewayTimeoutError [GatewayTimeoutException]")?;
        if let Some(inner_15) = &self.message {
            {
                write!(f, ": {}", inner_15)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for GatewayTimeoutError {}
/// See [`GatewayTimeoutError`](crate::error::GatewayTimeoutError).
pub mod gateway_timeout_error {

    /// A builder for [`GatewayTimeoutError`](crate::error::GatewayTimeoutError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`GatewayTimeoutError`](crate::error::GatewayTimeoutError).
        pub fn build(self) -> crate::error::GatewayTimeoutError {
            crate::error::GatewayTimeoutError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl GatewayTimeoutError {
    /// Creates a new builder-style object to manufacture [`GatewayTimeoutError`](crate::error::GatewayTimeoutError).
    pub fn builder() -> crate::error::gateway_timeout_error::Builder {
        crate::error::gateway_timeout_error::Builder::default()
    }
}

/// The server cannot process the request due to an apparent client error.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BadRequestError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl BadRequestError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl BadRequestError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for BadRequestError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "BadRequestError [BadRequestException]")?;
        if let Some(inner_16) = &self.message {
            {
                write!(f, ": {}", inner_16)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for BadRequestError {}
/// See [`BadRequestError`](crate::error::BadRequestError).
pub mod bad_request_error {

    /// A builder for [`BadRequestError`](crate::error::BadRequestError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`BadRequestError`](crate::error::BadRequestError).
        pub fn build(self) -> crate::error::BadRequestError {
            crate::error::BadRequestError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl BadRequestError {
    /// Creates a new builder-style object to manufacture [`BadRequestError`](crate::error::BadRequestError).
    pub fn builder() -> crate::error::bad_request_error::Builder {
        crate::error::bad_request_error::Builder::default()
    }
}

/// The server response for authorization failure.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct AccessDeniedError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    /// Classification of the exception type.
    #[doc(hidden)]
    pub code: std::option::Option<std::string::String>,
}
impl AccessDeniedError {
    /// Classification of the exception type.
    pub fn code(&self) -> std::option::Option<&str> {
        self.code.as_deref()
    }
}
impl AccessDeniedError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for AccessDeniedError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "AccessDeniedError [AccessDeniedException]")?;
        if let Some(inner_17) = &self.message {
            {
                write!(f, ": {}", inner_17)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for AccessDeniedError {}
/// See [`AccessDeniedError`](crate::error::AccessDeniedError).
pub mod access_denied_error {

    /// A builder for [`AccessDeniedError`](crate::error::AccessDeniedError).
    #[non_exhaustive]
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) code: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Human readable exception message.
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// Human readable exception message.
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Classification of the exception type.
        pub fn code(mut self, input: impl Into<std::string::String>) -> Self {
            self.code = Some(input.into());
            self
        }
        /// Classification of the exception type.
        pub fn set_code(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.code = input;
            self
        }
        /// Consumes the builder and constructs a [`AccessDeniedError`](crate::error::AccessDeniedError).
        pub fn build(self) -> crate::error::AccessDeniedError {
            crate::error::AccessDeniedError {
                message: self.message,
                code: self.code,
            }
        }
    }
}
impl AccessDeniedError {
    /// Creates a new builder-style object to manufacture [`AccessDeniedError`](crate::error::AccessDeniedError).
    pub fn builder() -> crate::error::access_denied_error::Builder {
        crate::error::access_denied_error::Builder::default()
    }
}

/// Error type for the `GetAwsAccess` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetAwsAccessError {
    /// Kind of error that occurred.
    pub kind: GetAwsAccessErrorKind,
    /// Additional metadata about the error, including error code, message, and request ID.
    pub(crate) meta: aws_smithy_types::Error,
}
impl aws_smithy_http::result::CreateUnhandledError for GetAwsAccessError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: GetAwsAccessErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `GetAwsAccess` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetAwsAccessErrorKind {
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
    GatewayTimeoutError(crate::error::GatewayTimeoutError),
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when the requested resource is capable of generating only content not acceptable according to the Accept headers sent in the request.
    NotAcceptableError(crate::error::NotAcceptableError),
    /// The server response for the usage plan quota exceeded error.
    QuotaExceededError(crate::error::QuotaExceededError),
    /// The server response for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    /// The server response when attempting to serialize the request.
    SerializationError(crate::error::SerializationError),
    /// The server cannot handle the request due to technical reasons.
    ServiceUnavailableError(crate::error::ServiceUnavailableError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server response when the operation specified could not be found.
    UnknownOperationError(crate::error::UnknownOperationError),
    /// The Stedi account has not been granted permission for this particular service.
    UnmappedError(crate::error::UnmappedError),
    /// The server response when a payload is of an unsupported media type.
    UnsupportedMediaTypeError(crate::error::UnsupportedMediaTypeError),
    /// 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.
    ValidationError(crate::error::ValidationError),
    ///
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
    ///
    /// When logging an error from the SDK, it is recommended that you either wrap the error in
    /// [`DisplayErrorContext`](crate::types::DisplayErrorContext), use another
    /// error reporter library that visits the error's cause/source chain, or call
    /// [`Error::source`](std::error::Error::source) for more details about the underlying cause.
    ///
    Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for GetAwsAccessError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            GetAwsAccessErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::GatewayTimeoutError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::NotAcceptableError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::QuotaExceededError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::SerializationError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::ServiceUnavailableError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::UnknownOperationError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::UnmappedError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::UnsupportedMediaTypeError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::ValidationError(_inner) => _inner.fmt(f),
            GetAwsAccessErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for GetAwsAccessError {
    fn code(&self) -> Option<&str> {
        GetAwsAccessError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            GetAwsAccessErrorKind::QuotaExceededError(inner) => Some(inner.retryable_error_kind()),
            GetAwsAccessErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            GetAwsAccessErrorKind::ServiceUnavailableError(inner) => {
                Some(inner.retryable_error_kind())
            }
            GetAwsAccessErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            _ => None,
        }
    }
}
impl GetAwsAccessError {
    /// Creates a new `GetAwsAccessError`.
    pub fn new(kind: GetAwsAccessErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    /// Creates the `GetAwsAccessError::Unhandled` variant from any error type.
    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: GetAwsAccessErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
            meta: Default::default(),
        }
    }

    /// Creates the `GetAwsAccessError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: GetAwsAccessErrorKind::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }

    /// Returns the error message if one is available.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    /// Returns error metadata, which includes the error code, message,
    /// request ID, and potentially additional information.
    pub fn meta(&self) -> &aws_smithy_types::Error {
        &self.meta
    }

    /// Returns the request ID if it's available.
    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    /// Returns the error code if it's available.
    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::GatewayTimeoutError`.
    pub fn is_gateway_timeout_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::GatewayTimeoutError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::NotAcceptableError`.
    pub fn is_not_acceptable_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::NotAcceptableError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::QuotaExceededError`.
    pub fn is_quota_exceeded_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::QuotaExceededError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::RequestTooLargeError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::ResourceConflictError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::ResourceNotFoundError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::SerializationError`.
    pub fn is_serialization_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::SerializationError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::ServiceUnavailableError`.
    pub fn is_service_unavailable_error(&self) -> bool {
        matches!(
            &self.kind,
            GetAwsAccessErrorKind::ServiceUnavailableError(_)
        )
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::UnknownOperationError`.
    pub fn is_unknown_operation_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::UnknownOperationError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::UnmappedError`.
    pub fn is_unmapped_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::UnmappedError(_))
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::UnsupportedMediaTypeError`.
    pub fn is_unsupported_media_type_error(&self) -> bool {
        matches!(
            &self.kind,
            GetAwsAccessErrorKind::UnsupportedMediaTypeError(_)
        )
    }
    /// Returns `true` if the error kind is `GetAwsAccessErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, GetAwsAccessErrorKind::ValidationError(_))
    }
}
impl std::error::Error for GetAwsAccessError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            GetAwsAccessErrorKind::AccessDeniedError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::BadRequestError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::GatewayTimeoutError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::InternalFailureError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::NotAcceptableError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::QuotaExceededError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::ResourceConflictError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::SerializationError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::ServiceUnavailableError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::ThrottlingError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::UnauthorizedError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::UnknownOperationError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::UnmappedError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::UnsupportedMediaTypeError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::ValidationError(_inner) => Some(_inner),
            GetAwsAccessErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

///
/// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
///
/// When logging an error from the SDK, it is recommended that you either wrap the error in
/// [`DisplayErrorContext`](crate::types::DisplayErrorContext), use another
/// error reporter library that visits the error's cause/source chain, or call
/// [`Error::source`](std::error::Error::source) for more details about the underlying cause.
///
#[derive(Debug)]
pub struct Unhandled {
    source: Box<dyn std::error::Error + Send + Sync + 'static>,
}
impl Unhandled {
    #[allow(unused)]
    pub(crate) fn new(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self { source }
    }
}
impl std::fmt::Display for Unhandled {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        write!(f, "unhandled error")
    }
}
impl std::error::Error for Unhandled {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(self.source.as_ref() as _)
    }
}