// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Error type for the `UpdateShareConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateShareConfigError {
    /// Kind of error that occurred.
    pub kind: UpdateShareConfigErrorKind,
    /// 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 UpdateShareConfigError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: UpdateShareConfigErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `UpdateShareConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateShareConfigErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 UpdateShareConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateShareConfigErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::ValidationError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            UpdateShareConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateShareConfigError {
    fn code(&self) -> Option<&str> {
        UpdateShareConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            UpdateShareConfigErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            UpdateShareConfigErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl UpdateShareConfigError {
    /// Creates a new `UpdateShareConfigError`.
    pub fn new(kind: UpdateShareConfigErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `UpdateShareConfigError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateShareConfigErrorKind::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 `UpdateShareConfigErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateShareConfigErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, UpdateShareConfigErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, UpdateShareConfigErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, UpdateShareConfigErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, UpdateShareConfigErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateShareConfigErrorKind::ResourceConflictError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, UpdateShareConfigErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateShareConfigErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateShareConfigErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateShareConfigErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for UpdateShareConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateShareConfigErrorKind::InternalFailureError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::ThrottlingError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::ValidationError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::AccessDeniedError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::UnauthorizedError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::ResourceConflictError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::BadRequestError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            UpdateShareConfigErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::RequestTooLargeCode>,
}
impl RequestTooLargeError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::RequestTooLargeCode> {
        self.code.as_ref()
    }
}
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_1) = &self.message {
            {
                write!(f, ": {}", inner_1)?;
            }
        }
        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<crate::model::RequestTooLargeCode>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::RequestTooLargeCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(
            mut self,
            input: std::option::Option<crate::model::RequestTooLargeCode>,
        ) -> 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 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::NotFoundCode>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub data: std::option::Option<crate::model::NotFoundData>,
}
impl ResourceNotFoundError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::NotFoundCode> {
        self.code.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn data(&self) -> std::option::Option<&crate::model::NotFoundData> {
        self.data.as_ref()
    }
}
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_2) = &self.message {
            {
                write!(f, ": {}", inner_2)?;
            }
        }
        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<crate::model::NotFoundCode>,
        pub(crate) data: std::option::Option<crate::model::NotFoundData>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::NotFoundCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(mut self, input: std::option::Option<crate::model::NotFoundCode>) -> Self {
            self.code = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn data(mut self, input: crate::model::NotFoundData) -> Self {
            self.data = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_data(mut self, input: std::option::Option<crate::model::NotFoundData>) -> Self {
            self.data = 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,
                data: self.data,
            }
        }
    }
}
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 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::BadRequestCode>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub field_list: std::option::Option<std::vec::Vec<crate::model::FieldListItem>>,
}
impl BadRequestError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::BadRequestCode> {
        self.code.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn field_list(&self) -> std::option::Option<&[crate::model::FieldListItem]> {
        self.field_list.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_3) = &self.message {
            {
                write!(f, ": {}", inner_3)?;
            }
        }
        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<crate::model::BadRequestCode>,
        pub(crate) field_list: std::option::Option<std::vec::Vec<crate::model::FieldListItem>>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::BadRequestCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(
            mut self,
            input: std::option::Option<crate::model::BadRequestCode>,
        ) -> Self {
            self.code = input;
            self
        }
        /// Appends an item to `field_list`.
        ///
        /// To override the contents of this collection use [`set_field_list`](Self::set_field_list).
        ///
        pub fn field_list(mut self, input: crate::model::FieldListItem) -> Self {
            let mut v = self.field_list.unwrap_or_default();
            v.push(input);
            self.field_list = Some(v);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_field_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::FieldListItem>>,
        ) -> Self {
            self.field_list = 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,
                field_list: self.field_list,
            }
        }
    }
}
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 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::ConflictCode>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub data: std::option::Option<crate::model::ConflictData>,
}
impl ResourceConflictError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::ConflictCode> {
        self.code.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn data(&self) -> std::option::Option<&crate::model::ConflictData> {
        self.data.as_ref()
    }
}
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_4) = &self.message {
            {
                write!(f, ": {}", inner_4)?;
            }
        }
        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<crate::model::ConflictCode>,
        pub(crate) data: std::option::Option<crate::model::ConflictData>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::ConflictCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(mut self, input: std::option::Option<crate::model::ConflictCode>) -> Self {
            self.code = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn data(mut self, input: crate::model::ConflictData) -> Self {
            self.data = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_data(mut self, input: std::option::Option<crate::model::ConflictData>) -> Self {
            self.data = 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,
                data: self.data,
            }
        }
    }
}
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 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::UnauthorizedCode>,
}
impl UnauthorizedError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::UnauthorizedCode> {
        self.code.as_ref()
    }
}
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<crate::model::UnauthorizedCode>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::UnauthorizedCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(
            mut self,
            input: std::option::Option<crate::model::UnauthorizedCode>,
        ) -> 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 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::AccessDeniedCode>,
}
impl AccessDeniedError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::AccessDeniedCode> {
        self.code.as_ref()
    }
}
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_6) = &self.message {
            {
                write!(f, ": {}", inner_6)?;
            }
        }
        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<crate::model::AccessDeniedCode>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::AccessDeniedCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(
            mut self,
            input: std::option::Option<crate::model::AccessDeniedCode>,
        ) -> 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()
    }
}

/// 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_7) = &self.message {
            {
                write!(f, ": {}", inner_7)?;
            }
        }
        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 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::ThrottleCode>,
}
impl ThrottlingError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::ThrottleCode> {
        self.code.as_ref()
    }
}
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_8) = &self.message {
            {
                write!(f, ": {}", inner_8)?;
            }
        }
        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<crate::model::ThrottleCode>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::ThrottleCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(mut self, input: std::option::Option<crate::model::ThrottleCode>) -> 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 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>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::InternalFailureCode>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub data: std::option::Option<crate::model::InternalFailureData>,
}
impl InternalFailureError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::InternalFailureCode> {
        self.code.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn data(&self) -> std::option::Option<&crate::model::InternalFailureData> {
        self.data.as_ref()
    }
}
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_9) = &self.message {
            {
                write!(f, ": {}", inner_9)?;
            }
        }
        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<crate::model::InternalFailureCode>,
        pub(crate) data: std::option::Option<crate::model::InternalFailureData>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::InternalFailureCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(
            mut self,
            input: std::option::Option<crate::model::InternalFailureCode>,
        ) -> Self {
            self.code = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn data(mut self, input: crate::model::InternalFailureData) -> Self {
            self.data = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_data(
            mut self,
            input: std::option::Option<crate::model::InternalFailureData>,
        ) -> Self {
            self.data = 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,
                data: self.data,
            }
        }
    }
}
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()
    }
}

/// Error type for the `ListPublicSharedGuideSamples` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListPublicSharedGuideSamplesError {
    /// Kind of error that occurred.
    pub kind: ListPublicSharedGuideSamplesErrorKind,
    /// 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 ListPublicSharedGuideSamplesError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ListPublicSharedGuideSamplesErrorKind::Unhandled(crate::error::Unhandled::new(
                source,
            )),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ListPublicSharedGuideSamples` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListPublicSharedGuideSamplesErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 ListPublicSharedGuideSamplesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListPublicSharedGuideSamplesErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ListPublicSharedGuideSamplesErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ListPublicSharedGuideSamplesErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ListPublicSharedGuideSamplesErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            ListPublicSharedGuideSamplesErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            ListPublicSharedGuideSamplesErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            ListPublicSharedGuideSamplesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ListPublicSharedGuideSamplesError {
    fn code(&self) -> Option<&str> {
        ListPublicSharedGuideSamplesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ListPublicSharedGuideSamplesErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl ListPublicSharedGuideSamplesError {
    /// Creates a new `ListPublicSharedGuideSamplesError`.
    pub fn new(kind: ListPublicSharedGuideSamplesErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ListPublicSharedGuideSamplesError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListPublicSharedGuideSamplesErrorKind::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 `ListPublicSharedGuideSamplesErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicSharedGuideSamplesErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicSharedGuideSamplesErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicSharedGuideSamplesErrorKind::ThrottlingError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicSharedGuideSamplesErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicSharedGuideSamplesErrorKind::ValidationError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicSharedGuideSamplesErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicSharedGuideSamplesErrorKind::AccessDeniedError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicSharedGuideSamplesErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicSharedGuideSamplesErrorKind::UnauthorizedError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicSharedGuideSamplesErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicSharedGuideSamplesErrorKind::ResourceNotFoundError(_)
        )
    }
}
impl std::error::Error for ListPublicSharedGuideSamplesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListPublicSharedGuideSamplesErrorKind::InternalFailureError(_inner) => Some(_inner),
            ListPublicSharedGuideSamplesErrorKind::ThrottlingError(_inner) => Some(_inner),
            ListPublicSharedGuideSamplesErrorKind::ValidationError(_inner) => Some(_inner),
            ListPublicSharedGuideSamplesErrorKind::AccessDeniedError(_inner) => Some(_inner),
            ListPublicSharedGuideSamplesErrorKind::UnauthorizedError(_inner) => Some(_inner),
            ListPublicSharedGuideSamplesErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            ListPublicSharedGuideSamplesErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `GetPublicSharedGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPublicSharedGuideError {
    /// Kind of error that occurred.
    pub kind: GetPublicSharedGuideErrorKind,
    /// 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 GetPublicSharedGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: GetPublicSharedGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `GetPublicSharedGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPublicSharedGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 GetPublicSharedGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            GetPublicSharedGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            GetPublicSharedGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            GetPublicSharedGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            GetPublicSharedGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            GetPublicSharedGuideErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            GetPublicSharedGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPublicSharedGuideError {
    fn code(&self) -> Option<&str> {
        GetPublicSharedGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            GetPublicSharedGuideErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl GetPublicSharedGuideError {
    /// Creates a new `GetPublicSharedGuideError`.
    pub fn new(kind: GetPublicSharedGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `GetPublicSharedGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: GetPublicSharedGuideErrorKind::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 `GetPublicSharedGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicSharedGuideErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicSharedGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicSharedGuideErrorKind::ThrottlingError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicSharedGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicSharedGuideErrorKind::ValidationError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicSharedGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicSharedGuideErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicSharedGuideErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicSharedGuideErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for GetPublicSharedGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            GetPublicSharedGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            GetPublicSharedGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            GetPublicSharedGuideErrorKind::ValidationError(_inner) => Some(_inner),
            GetPublicSharedGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            GetPublicSharedGuideErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            GetPublicSharedGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `ListPublicGuides` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListPublicGuidesError {
    /// Kind of error that occurred.
    pub kind: ListPublicGuidesErrorKind,
    /// 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 ListPublicGuidesError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ListPublicGuidesErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ListPublicGuides` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListPublicGuidesErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 ListPublicGuidesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListPublicGuidesErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ListPublicGuidesErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ListPublicGuidesErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ListPublicGuidesErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            ListPublicGuidesErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            ListPublicGuidesErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            ListPublicGuidesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ListPublicGuidesError {
    fn code(&self) -> Option<&str> {
        ListPublicGuidesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ListPublicGuidesErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            _ => None,
        }
    }
}
impl ListPublicGuidesError {
    /// Creates a new `ListPublicGuidesError`.
    pub fn new(kind: ListPublicGuidesErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ListPublicGuidesError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListPublicGuidesErrorKind::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 `ListPublicGuidesErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuidesErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicGuidesErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, ListPublicGuidesErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `ListPublicGuidesErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, ListPublicGuidesErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `ListPublicGuidesErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, ListPublicGuidesErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `ListPublicGuidesErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuidesErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicGuidesErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuidesErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for ListPublicGuidesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListPublicGuidesErrorKind::InternalFailureError(_inner) => Some(_inner),
            ListPublicGuidesErrorKind::ThrottlingError(_inner) => Some(_inner),
            ListPublicGuidesErrorKind::ValidationError(_inner) => Some(_inner),
            ListPublicGuidesErrorKind::BadRequestError(_inner) => Some(_inner),
            ListPublicGuidesErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            ListPublicGuidesErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            ListPublicGuidesErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `GetPublicGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPublicGuideError {
    /// Kind of error that occurred.
    pub kind: GetPublicGuideErrorKind,
    /// 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 GetPublicGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: GetPublicGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `GetPublicGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPublicGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 GetPublicGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            GetPublicGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            GetPublicGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            GetPublicGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            GetPublicGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            GetPublicGuideErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            GetPublicGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPublicGuideError {
    fn code(&self) -> Option<&str> {
        GetPublicGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            GetPublicGuideErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            _ => None,
        }
    }
}
impl GetPublicGuideError {
    /// Creates a new `GetPublicGuideError`.
    pub fn new(kind: GetPublicGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `GetPublicGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: GetPublicGuideErrorKind::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 `GetPublicGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, GetPublicGuideErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `GetPublicGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, GetPublicGuideErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `GetPublicGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, GetPublicGuideErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `GetPublicGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicGuideErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicGuideErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(&self.kind, GetPublicGuideErrorKind::RequestTooLargeError(_))
    }
}
impl std::error::Error for GetPublicGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            GetPublicGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            GetPublicGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            GetPublicGuideErrorKind::ValidationError(_inner) => Some(_inner),
            GetPublicGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            GetPublicGuideErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            GetPublicGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `ListPublicGuideSamples` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListPublicGuideSamplesError {
    /// Kind of error that occurred.
    pub kind: ListPublicGuideSamplesErrorKind,
    /// 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 ListPublicGuideSamplesError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ListPublicGuideSamplesErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ListPublicGuideSamples` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListPublicGuideSamplesErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 ListPublicGuideSamplesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListPublicGuideSamplesErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ListPublicGuideSamplesErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ListPublicGuideSamplesErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ListPublicGuideSamplesErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            ListPublicGuideSamplesErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            ListPublicGuideSamplesErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            ListPublicGuideSamplesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ListPublicGuideSamplesError {
    fn code(&self) -> Option<&str> {
        ListPublicGuideSamplesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ListPublicGuideSamplesErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl ListPublicGuideSamplesError {
    /// Creates a new `ListPublicGuideSamplesError`.
    pub fn new(kind: ListPublicGuideSamplesErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ListPublicGuideSamplesError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListPublicGuideSamplesErrorKind::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 `ListPublicGuideSamplesErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuideSamplesErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicGuideSamplesErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuideSamplesErrorKind::ThrottlingError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicGuideSamplesErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuideSamplesErrorKind::ValidationError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicGuideSamplesErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuideSamplesErrorKind::AccessDeniedError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicGuideSamplesErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuideSamplesErrorKind::UnauthorizedError(_)
        )
    }
    /// Returns `true` if the error kind is `ListPublicGuideSamplesErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            ListPublicGuideSamplesErrorKind::ResourceNotFoundError(_)
        )
    }
}
impl std::error::Error for ListPublicGuideSamplesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListPublicGuideSamplesErrorKind::InternalFailureError(_inner) => Some(_inner),
            ListPublicGuideSamplesErrorKind::ThrottlingError(_inner) => Some(_inner),
            ListPublicGuideSamplesErrorKind::ValidationError(_inner) => Some(_inner),
            ListPublicGuideSamplesErrorKind::AccessDeniedError(_inner) => Some(_inner),
            ListPublicGuideSamplesErrorKind::UnauthorizedError(_inner) => Some(_inner),
            ListPublicGuideSamplesErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            ListPublicGuideSamplesErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `GetPublicAccountConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetPublicAccountConfigError {
    /// Kind of error that occurred.
    pub kind: GetPublicAccountConfigErrorKind,
    /// 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 GetPublicAccountConfigError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: GetPublicAccountConfigErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `GetPublicAccountConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetPublicAccountConfigErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 GetPublicAccountConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            GetPublicAccountConfigErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            GetPublicAccountConfigErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            GetPublicAccountConfigErrorKind::ValidationError(_inner) => _inner.fmt(f),
            GetPublicAccountConfigErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            GetPublicAccountConfigErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            GetPublicAccountConfigErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            GetPublicAccountConfigErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            GetPublicAccountConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for GetPublicAccountConfigError {
    fn code(&self) -> Option<&str> {
        GetPublicAccountConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            GetPublicAccountConfigErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl GetPublicAccountConfigError {
    /// Creates a new `GetPublicAccountConfigError`.
    pub fn new(kind: GetPublicAccountConfigErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `GetPublicAccountConfigError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: GetPublicAccountConfigErrorKind::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 `GetPublicAccountConfigErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicAccountConfigErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicAccountConfigErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicAccountConfigErrorKind::ThrottlingError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicAccountConfigErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicAccountConfigErrorKind::ValidationError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicAccountConfigErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicAccountConfigErrorKind::AccessDeniedError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicAccountConfigErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicAccountConfigErrorKind::UnauthorizedError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicAccountConfigErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicAccountConfigErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `GetPublicAccountConfigErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            GetPublicAccountConfigErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for GetPublicAccountConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            GetPublicAccountConfigErrorKind::InternalFailureError(_inner) => Some(_inner),
            GetPublicAccountConfigErrorKind::ThrottlingError(_inner) => Some(_inner),
            GetPublicAccountConfigErrorKind::ValidationError(_inner) => Some(_inner),
            GetPublicAccountConfigErrorKind::AccessDeniedError(_inner) => Some(_inner),
            GetPublicAccountConfigErrorKind::UnauthorizedError(_inner) => Some(_inner),
            GetPublicAccountConfigErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            GetPublicAccountConfigErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            GetPublicAccountConfigErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `RevertGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct RevertGuideError {
    /// Kind of error that occurred.
    pub kind: RevertGuideErrorKind,
    /// 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 RevertGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: RevertGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `RevertGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum RevertGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 RevertGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            RevertGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            RevertGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for RevertGuideError {
    fn code(&self) -> Option<&str> {
        RevertGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            RevertGuideErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            RevertGuideErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl RevertGuideError {
    /// Creates a new `RevertGuideError`.
    pub fn new(kind: RevertGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `RevertGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: RevertGuideErrorKind::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 `RevertGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `RevertGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `RevertGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `RevertGuideErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `RevertGuideErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `RevertGuideErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::ResourceConflictError(_))
    }
    /// Returns `true` if the error kind is `RevertGuideErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `RevertGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(&self.kind, RevertGuideErrorKind::ResourceNotFoundError(_))
    }
}
impl std::error::Error for RevertGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            RevertGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            RevertGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            RevertGuideErrorKind::ValidationError(_inner) => Some(_inner),
            RevertGuideErrorKind::AccessDeniedError(_inner) => Some(_inner),
            RevertGuideErrorKind::UnauthorizedError(_inner) => Some(_inner),
            RevertGuideErrorKind::ResourceConflictError(_inner) => Some(_inner),
            RevertGuideErrorKind::BadRequestError(_inner) => Some(_inner),
            RevertGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            RevertGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `PublishGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct PublishGuideError {
    /// Kind of error that occurred.
    pub kind: PublishGuideErrorKind,
    /// 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 PublishGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: PublishGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `PublishGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum PublishGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 PublishGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            PublishGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            PublishGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for PublishGuideError {
    fn code(&self) -> Option<&str> {
        PublishGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            PublishGuideErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            PublishGuideErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl PublishGuideError {
    /// Creates a new `PublishGuideError`.
    pub fn new(kind: PublishGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `PublishGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: PublishGuideErrorKind::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 `PublishGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `PublishGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `PublishGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `PublishGuideErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `PublishGuideErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `PublishGuideErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::ResourceConflictError(_))
    }
    /// Returns `true` if the error kind is `PublishGuideErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `PublishGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(&self.kind, PublishGuideErrorKind::ResourceNotFoundError(_))
    }
}
impl std::error::Error for PublishGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            PublishGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            PublishGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            PublishGuideErrorKind::ValidationError(_inner) => Some(_inner),
            PublishGuideErrorKind::AccessDeniedError(_inner) => Some(_inner),
            PublishGuideErrorKind::UnauthorizedError(_inner) => Some(_inner),
            PublishGuideErrorKind::ResourceConflictError(_inner) => Some(_inner),
            PublishGuideErrorKind::BadRequestError(_inner) => Some(_inner),
            PublishGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            PublishGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `ChangeGuideVisibility` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ChangeGuideVisibilityError {
    /// Kind of error that occurred.
    pub kind: ChangeGuideVisibilityErrorKind,
    /// 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 ChangeGuideVisibilityError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ChangeGuideVisibilityErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ChangeGuideVisibility` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ChangeGuideVisibilityErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 ChangeGuideVisibilityError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ChangeGuideVisibilityErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            ChangeGuideVisibilityErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ChangeGuideVisibilityError {
    fn code(&self) -> Option<&str> {
        ChangeGuideVisibilityError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ChangeGuideVisibilityErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            ChangeGuideVisibilityErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl ChangeGuideVisibilityError {
    /// Creates a new `ChangeGuideVisibilityError`.
    pub fn new(kind: ChangeGuideVisibilityErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ChangeGuideVisibilityError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ChangeGuideVisibilityErrorKind::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 `ChangeGuideVisibilityErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `ChangeGuideVisibilityErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::ThrottlingError(_)
        )
    }
    /// Returns `true` if the error kind is `ChangeGuideVisibilityErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::ValidationError(_)
        )
    }
    /// Returns `true` if the error kind is `ChangeGuideVisibilityErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::AccessDeniedError(_)
        )
    }
    /// Returns `true` if the error kind is `ChangeGuideVisibilityErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::UnauthorizedError(_)
        )
    }
    /// Returns `true` if the error kind is `ChangeGuideVisibilityErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::ResourceConflictError(_)
        )
    }
    /// Returns `true` if the error kind is `ChangeGuideVisibilityErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::BadRequestError(_)
        )
    }
    /// Returns `true` if the error kind is `ChangeGuideVisibilityErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            ChangeGuideVisibilityErrorKind::ResourceNotFoundError(_)
        )
    }
}
impl std::error::Error for ChangeGuideVisibilityError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ChangeGuideVisibilityErrorKind::InternalFailureError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::ThrottlingError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::ValidationError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::AccessDeniedError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::UnauthorizedError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::ResourceConflictError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::BadRequestError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            ChangeGuideVisibilityErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `ListGuides` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListGuidesError {
    /// Kind of error that occurred.
    pub kind: ListGuidesErrorKind,
    /// 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 ListGuidesError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ListGuidesErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ListGuides` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListGuidesErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    ///
    /// 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 ListGuidesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListGuidesErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ListGuidesErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ListGuidesErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ListGuidesErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            ListGuidesErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            ListGuidesErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            ListGuidesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ListGuidesError {
    fn code(&self) -> Option<&str> {
        ListGuidesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ListGuidesErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            _ => None,
        }
    }
}
impl ListGuidesError {
    /// Creates a new `ListGuidesError`.
    pub fn new(kind: ListGuidesErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ListGuidesError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListGuidesErrorKind::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 `ListGuidesErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, ListGuidesErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `ListGuidesErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, ListGuidesErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `ListGuidesErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, ListGuidesErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `ListGuidesErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, ListGuidesErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `ListGuidesErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, ListGuidesErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `ListGuidesErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, ListGuidesErrorKind::BadRequestError(_))
    }
}
impl std::error::Error for ListGuidesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListGuidesErrorKind::InternalFailureError(_inner) => Some(_inner),
            ListGuidesErrorKind::ThrottlingError(_inner) => Some(_inner),
            ListGuidesErrorKind::ValidationError(_inner) => Some(_inner),
            ListGuidesErrorKind::AccessDeniedError(_inner) => Some(_inner),
            ListGuidesErrorKind::UnauthorizedError(_inner) => Some(_inner),
            ListGuidesErrorKind::BadRequestError(_inner) => Some(_inner),
            ListGuidesErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `CreateGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateGuideError {
    /// Kind of error that occurred.
    pub kind: CreateGuideErrorKind,
    /// 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 CreateGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: CreateGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `CreateGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response for the request too large error.
    ResponseTooLargeError(crate::error::ResponseTooLargeError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 CreateGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            CreateGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::ResponseTooLargeError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            CreateGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateGuideError {
    fn code(&self) -> Option<&str> {
        CreateGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            CreateGuideErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            CreateGuideErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl CreateGuideError {
    /// Creates a new `CreateGuideError`.
    pub fn new(kind: CreateGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `CreateGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: CreateGuideErrorKind::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 `CreateGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::ResponseTooLargeError`.
    pub fn is_response_too_large_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::ResponseTooLargeError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::ResourceConflictError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::ResourceNotFoundError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(&self.kind, CreateGuideErrorKind::RequestTooLargeError(_))
    }
}
impl std::error::Error for CreateGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            CreateGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            CreateGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            CreateGuideErrorKind::ValidationError(_inner) => Some(_inner),
            CreateGuideErrorKind::AccessDeniedError(_inner) => Some(_inner),
            CreateGuideErrorKind::ResponseTooLargeError(_inner) => Some(_inner),
            CreateGuideErrorKind::UnauthorizedError(_inner) => Some(_inner),
            CreateGuideErrorKind::ResourceConflictError(_inner) => Some(_inner),
            CreateGuideErrorKind::BadRequestError(_inner) => Some(_inner),
            CreateGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            CreateGuideErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            CreateGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// The server response for the request too large error.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResponseTooLargeError {
    /// Human readable exception message.
    #[doc(hidden)]
    pub message: std::option::Option<std::string::String>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub code: std::option::Option<crate::model::ResponseTooLargeCode>,
    #[allow(missing_docs)] // documentation missing in model
    #[doc(hidden)]
    pub data: std::option::Option<crate::model::ResponseTooLargeData>,
}
impl ResponseTooLargeError {
    #[allow(missing_docs)] // documentation missing in model
    pub fn code(&self) -> std::option::Option<&crate::model::ResponseTooLargeCode> {
        self.code.as_ref()
    }
    #[allow(missing_docs)] // documentation missing in model
    pub fn data(&self) -> std::option::Option<&crate::model::ResponseTooLargeData> {
        self.data.as_ref()
    }
}
impl ResponseTooLargeError {
    /// Returns the error message.
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ResponseTooLargeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ResponseTooLargeError [ResponseTooLargeException]")?;
        if let Some(inner_10) = &self.message {
            {
                write!(f, ": {}", inner_10)?;
            }
        }
        Ok(())
    }
}
impl std::error::Error for ResponseTooLargeError {}
/// See [`ResponseTooLargeError`](crate::error::ResponseTooLargeError).
pub mod response_too_large_error {

    /// A builder for [`ResponseTooLargeError`](crate::error::ResponseTooLargeError).
    #[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<crate::model::ResponseTooLargeCode>,
        pub(crate) data: std::option::Option<crate::model::ResponseTooLargeData>,
    }
    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
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn code(mut self, input: crate::model::ResponseTooLargeCode) -> Self {
            self.code = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_code(
            mut self,
            input: std::option::Option<crate::model::ResponseTooLargeCode>,
        ) -> Self {
            self.code = input;
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn data(mut self, input: crate::model::ResponseTooLargeData) -> Self {
            self.data = Some(input);
            self
        }
        #[allow(missing_docs)] // documentation missing in model
        pub fn set_data(
            mut self,
            input: std::option::Option<crate::model::ResponseTooLargeData>,
        ) -> Self {
            self.data = input;
            self
        }
        /// Consumes the builder and constructs a [`ResponseTooLargeError`](crate::error::ResponseTooLargeError).
        pub fn build(self) -> crate::error::ResponseTooLargeError {
            crate::error::ResponseTooLargeError {
                message: self.message,
                code: self.code,
                data: self.data,
            }
        }
    }
}
impl ResponseTooLargeError {
    /// Creates a new builder-style object to manufacture [`ResponseTooLargeError`](crate::error::ResponseTooLargeError).
    pub fn builder() -> crate::error::response_too_large_error::Builder {
        crate::error::response_too_large_error::Builder::default()
    }
}

/// Error type for the `DeleteGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteGuideError {
    /// Kind of error that occurred.
    pub kind: DeleteGuideErrorKind,
    /// 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 DeleteGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: DeleteGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `DeleteGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// 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),
    ///
    /// 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 DeleteGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DeleteGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            DeleteGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            DeleteGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            DeleteGuideErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            DeleteGuideErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            DeleteGuideErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            DeleteGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            DeleteGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteGuideError {
    fn code(&self) -> Option<&str> {
        DeleteGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            DeleteGuideErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            DeleteGuideErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl DeleteGuideError {
    /// Creates a new `DeleteGuideError`.
    pub fn new(kind: DeleteGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `DeleteGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DeleteGuideErrorKind::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 `DeleteGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideErrorKind::ResourceConflictError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideErrorKind::ResourceNotFoundError(_))
    }
}
impl std::error::Error for DeleteGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DeleteGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            DeleteGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            DeleteGuideErrorKind::ValidationError(_inner) => Some(_inner),
            DeleteGuideErrorKind::AccessDeniedError(_inner) => Some(_inner),
            DeleteGuideErrorKind::UnauthorizedError(_inner) => Some(_inner),
            DeleteGuideErrorKind::ResourceConflictError(_inner) => Some(_inner),
            DeleteGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            DeleteGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `UpdateGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateGuideError {
    /// Kind of error that occurred.
    pub kind: UpdateGuideErrorKind,
    /// 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 UpdateGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: UpdateGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `UpdateGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 UpdateGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            UpdateGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateGuideError {
    fn code(&self) -> Option<&str> {
        UpdateGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            UpdateGuideErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            UpdateGuideErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl UpdateGuideError {
    /// Creates a new `UpdateGuideError`.
    pub fn new(kind: UpdateGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `UpdateGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateGuideErrorKind::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 `UpdateGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::ResourceConflictError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::ResourceNotFoundError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideErrorKind::RequestTooLargeError(_))
    }
}
impl std::error::Error for UpdateGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            UpdateGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            UpdateGuideErrorKind::ValidationError(_inner) => Some(_inner),
            UpdateGuideErrorKind::AccessDeniedError(_inner) => Some(_inner),
            UpdateGuideErrorKind::UnauthorizedError(_inner) => Some(_inner),
            UpdateGuideErrorKind::ResourceConflictError(_inner) => Some(_inner),
            UpdateGuideErrorKind::BadRequestError(_inner) => Some(_inner),
            UpdateGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            UpdateGuideErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            UpdateGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `GetGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetGuideError {
    /// Kind of error that occurred.
    pub kind: GetGuideErrorKind,
    /// 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 GetGuideError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: GetGuideErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `GetGuide` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetGuideErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 GetGuideError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            GetGuideErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            GetGuideErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            GetGuideErrorKind::ValidationError(_inner) => _inner.fmt(f),
            GetGuideErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            GetGuideErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            GetGuideErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            GetGuideErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for GetGuideError {
    fn code(&self) -> Option<&str> {
        GetGuideError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            GetGuideErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            _ => None,
        }
    }
}
impl GetGuideError {
    /// Creates a new `GetGuideError`.
    pub fn new(kind: GetGuideErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `GetGuideError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: GetGuideErrorKind::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 `GetGuideErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(&self.kind, GetGuideErrorKind::InternalFailureError(_))
    }
    /// Returns `true` if the error kind is `GetGuideErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, GetGuideErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `GetGuideErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, GetGuideErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `GetGuideErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, GetGuideErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `GetGuideErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, GetGuideErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `GetGuideErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(&self.kind, GetGuideErrorKind::ResourceNotFoundError(_))
    }
}
impl std::error::Error for GetGuideError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            GetGuideErrorKind::InternalFailureError(_inner) => Some(_inner),
            GetGuideErrorKind::ThrottlingError(_inner) => Some(_inner),
            GetGuideErrorKind::ValidationError(_inner) => Some(_inner),
            GetGuideErrorKind::AccessDeniedError(_inner) => Some(_inner),
            GetGuideErrorKind::UnauthorizedError(_inner) => Some(_inner),
            GetGuideErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            GetGuideErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `ListGuideSamples` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListGuideSamplesError {
    /// Kind of error that occurred.
    pub kind: ListGuideSamplesErrorKind,
    /// 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 ListGuideSamplesError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ListGuideSamplesErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ListGuideSamples` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListGuideSamplesErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 ListGuideSamplesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListGuideSamplesErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ListGuideSamplesErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ListGuideSamplesErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ListGuideSamplesErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            ListGuideSamplesErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            ListGuideSamplesErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            ListGuideSamplesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ListGuideSamplesError {
    fn code(&self) -> Option<&str> {
        ListGuideSamplesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ListGuideSamplesErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            _ => None,
        }
    }
}
impl ListGuideSamplesError {
    /// Creates a new `ListGuideSamplesError`.
    pub fn new(kind: ListGuideSamplesErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ListGuideSamplesError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListGuideSamplesErrorKind::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 `ListGuideSamplesErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            ListGuideSamplesErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `ListGuideSamplesErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, ListGuideSamplesErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `ListGuideSamplesErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, ListGuideSamplesErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `ListGuideSamplesErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, ListGuideSamplesErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `ListGuideSamplesErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, ListGuideSamplesErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `ListGuideSamplesErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            ListGuideSamplesErrorKind::ResourceNotFoundError(_)
        )
    }
}
impl std::error::Error for ListGuideSamplesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListGuideSamplesErrorKind::InternalFailureError(_inner) => Some(_inner),
            ListGuideSamplesErrorKind::ThrottlingError(_inner) => Some(_inner),
            ListGuideSamplesErrorKind::ValidationError(_inner) => Some(_inner),
            ListGuideSamplesErrorKind::AccessDeniedError(_inner) => Some(_inner),
            ListGuideSamplesErrorKind::UnauthorizedError(_inner) => Some(_inner),
            ListGuideSamplesErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            ListGuideSamplesErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `CreateGuideSample` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateGuideSampleError {
    /// Kind of error that occurred.
    pub kind: CreateGuideSampleErrorKind,
    /// 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 CreateGuideSampleError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: CreateGuideSampleErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `CreateGuideSample` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateGuideSampleErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response for the request too large error.
    ResponseTooLargeError(crate::error::ResponseTooLargeError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 CreateGuideSampleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            CreateGuideSampleErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::ValidationError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::ResponseTooLargeError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            CreateGuideSampleErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for CreateGuideSampleError {
    fn code(&self) -> Option<&str> {
        CreateGuideSampleError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            CreateGuideSampleErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            CreateGuideSampleErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl CreateGuideSampleError {
    /// Creates a new `CreateGuideSampleError`.
    pub fn new(kind: CreateGuideSampleErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `CreateGuideSampleError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: CreateGuideSampleErrorKind::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 `CreateGuideSampleErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            CreateGuideSampleErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, CreateGuideSampleErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, CreateGuideSampleErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, CreateGuideSampleErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::ResponseTooLargeError`.
    pub fn is_response_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            CreateGuideSampleErrorKind::ResponseTooLargeError(_)
        )
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, CreateGuideSampleErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(
            &self.kind,
            CreateGuideSampleErrorKind::ResourceConflictError(_)
        )
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, CreateGuideSampleErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            CreateGuideSampleErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `CreateGuideSampleErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            CreateGuideSampleErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for CreateGuideSampleError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            CreateGuideSampleErrorKind::InternalFailureError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::ThrottlingError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::ValidationError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::AccessDeniedError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::ResponseTooLargeError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::UnauthorizedError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::ResourceConflictError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::BadRequestError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            CreateGuideSampleErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `DeleteGuideSample` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteGuideSampleError {
    /// Kind of error that occurred.
    pub kind: DeleteGuideSampleErrorKind,
    /// 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 DeleteGuideSampleError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: DeleteGuideSampleErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `DeleteGuideSample` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteGuideSampleErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 DeleteGuideSampleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DeleteGuideSampleErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::ValidationError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            DeleteGuideSampleErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for DeleteGuideSampleError {
    fn code(&self) -> Option<&str> {
        DeleteGuideSampleError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            DeleteGuideSampleErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            DeleteGuideSampleErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl DeleteGuideSampleError {
    /// Creates a new `DeleteGuideSampleError`.
    pub fn new(kind: DeleteGuideSampleErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `DeleteGuideSampleError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DeleteGuideSampleErrorKind::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 `DeleteGuideSampleErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            DeleteGuideSampleErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `DeleteGuideSampleErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideSampleErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideSampleErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideSampleErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideSampleErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideSampleErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideSampleErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideSampleErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideSampleErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(
            &self.kind,
            DeleteGuideSampleErrorKind::ResourceConflictError(_)
        )
    }
    /// Returns `true` if the error kind is `DeleteGuideSampleErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, DeleteGuideSampleErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `DeleteGuideSampleErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            DeleteGuideSampleErrorKind::ResourceNotFoundError(_)
        )
    }
}
impl std::error::Error for DeleteGuideSampleError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DeleteGuideSampleErrorKind::InternalFailureError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::ThrottlingError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::ValidationError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::AccessDeniedError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::UnauthorizedError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::ResourceConflictError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::BadRequestError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            DeleteGuideSampleErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `UpdateGuideSample` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateGuideSampleError {
    /// Kind of error that occurred.
    pub kind: UpdateGuideSampleErrorKind,
    /// 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 UpdateGuideSampleError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: UpdateGuideSampleErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `UpdateGuideSample` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateGuideSampleErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 UpdateGuideSampleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateGuideSampleErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::ValidationError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            UpdateGuideSampleErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateGuideSampleError {
    fn code(&self) -> Option<&str> {
        UpdateGuideSampleError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            UpdateGuideSampleErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            UpdateGuideSampleErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl UpdateGuideSampleError {
    /// Creates a new `UpdateGuideSampleError`.
    pub fn new(kind: UpdateGuideSampleErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `UpdateGuideSampleError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateGuideSampleErrorKind::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 `UpdateGuideSampleErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateGuideSampleErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideSampleErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideSampleErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideSampleErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideSampleErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateGuideSampleErrorKind::ResourceConflictError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, UpdateGuideSampleErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateGuideSampleErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateGuideSampleErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateGuideSampleErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for UpdateGuideSampleError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateGuideSampleErrorKind::InternalFailureError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::ThrottlingError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::ValidationError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::AccessDeniedError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::UnauthorizedError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::ResourceConflictError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::BadRequestError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            UpdateGuideSampleErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `UpdateAccountConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateAccountConfigError {
    /// Kind of error that occurred.
    pub kind: UpdateAccountConfigErrorKind,
    /// 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 UpdateAccountConfigError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: UpdateAccountConfigErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `UpdateAccountConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateAccountConfigErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server could not process the request because of conflict in the current state of the resource.
    ResourceConflictError(crate::error::ResourceConflictError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 UpdateAccountConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateAccountConfigErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::ValidationError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::ResourceConflictError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            UpdateAccountConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for UpdateAccountConfigError {
    fn code(&self) -> Option<&str> {
        UpdateAccountConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            UpdateAccountConfigErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            UpdateAccountConfigErrorKind::ResourceConflictError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl UpdateAccountConfigError {
    /// Creates a new `UpdateAccountConfigError`.
    pub fn new(kind: UpdateAccountConfigErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `UpdateAccountConfigError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateAccountConfigErrorKind::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 `UpdateAccountConfigErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAccountConfigErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, UpdateAccountConfigErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, UpdateAccountConfigErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAccountConfigErrorKind::AccessDeniedError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAccountConfigErrorKind::UnauthorizedError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::ResourceConflictError`.
    pub fn is_resource_conflict_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAccountConfigErrorKind::ResourceConflictError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, UpdateAccountConfigErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAccountConfigErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `UpdateAccountConfigErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAccountConfigErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for UpdateAccountConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateAccountConfigErrorKind::InternalFailureError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::ThrottlingError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::ValidationError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::AccessDeniedError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::UnauthorizedError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::ResourceConflictError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::BadRequestError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            UpdateAccountConfigErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `GetAccountConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetAccountConfigError {
    /// Kind of error that occurred.
    pub kind: GetAccountConfigErrorKind,
    /// 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 GetAccountConfigError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: GetAccountConfigErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `GetAccountConfig` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetAccountConfigErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 GetAccountConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            GetAccountConfigErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            GetAccountConfigErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            GetAccountConfigErrorKind::ValidationError(_inner) => _inner.fmt(f),
            GetAccountConfigErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            GetAccountConfigErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            GetAccountConfigErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            GetAccountConfigErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            GetAccountConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for GetAccountConfigError {
    fn code(&self) -> Option<&str> {
        GetAccountConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            GetAccountConfigErrorKind::ThrottlingError(inner) => Some(inner.retryable_error_kind()),
            _ => None,
        }
    }
}
impl GetAccountConfigError {
    /// Creates a new `GetAccountConfigError`.
    pub fn new(kind: GetAccountConfigErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `GetAccountConfigError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: GetAccountConfigErrorKind::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 `GetAccountConfigErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            GetAccountConfigErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `GetAccountConfigErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, GetAccountConfigErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `GetAccountConfigErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, GetAccountConfigErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `GetAccountConfigErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(&self.kind, GetAccountConfigErrorKind::AccessDeniedError(_))
    }
    /// Returns `true` if the error kind is `GetAccountConfigErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(&self.kind, GetAccountConfigErrorKind::UnauthorizedError(_))
    }
    /// Returns `true` if the error kind is `GetAccountConfigErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            GetAccountConfigErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `GetAccountConfigErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            GetAccountConfigErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for GetAccountConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            GetAccountConfigErrorKind::InternalFailureError(_inner) => Some(_inner),
            GetAccountConfigErrorKind::ThrottlingError(_inner) => Some(_inner),
            GetAccountConfigErrorKind::ValidationError(_inner) => Some(_inner),
            GetAccountConfigErrorKind::AccessDeniedError(_inner) => Some(_inner),
            GetAccountConfigErrorKind::UnauthorizedError(_inner) => Some(_inner),
            GetAccountConfigErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            GetAccountConfigErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            GetAccountConfigErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `ListX12TransactionSets` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListX12TransactionSetsError {
    /// Kind of error that occurred.
    pub kind: ListX12TransactionSetsErrorKind,
    /// 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 ListX12TransactionSetsError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ListX12TransactionSetsErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ListX12TransactionSets` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListX12TransactionSetsErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 ListX12TransactionSetsError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListX12TransactionSetsErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ListX12TransactionSetsErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ListX12TransactionSetsErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ListX12TransactionSetsErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            ListX12TransactionSetsErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            ListX12TransactionSetsErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            ListX12TransactionSetsErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            ListX12TransactionSetsErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ListX12TransactionSetsError {
    fn code(&self) -> Option<&str> {
        ListX12TransactionSetsError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ListX12TransactionSetsErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl ListX12TransactionSetsError {
    /// Creates a new `ListX12TransactionSetsError`.
    pub fn new(kind: ListX12TransactionSetsErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ListX12TransactionSetsError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListX12TransactionSetsErrorKind::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 `ListX12TransactionSetsErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            ListX12TransactionSetsErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `ListX12TransactionSetsErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(
            &self.kind,
            ListX12TransactionSetsErrorKind::ThrottlingError(_)
        )
    }
    /// Returns `true` if the error kind is `ListX12TransactionSetsErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(
            &self.kind,
            ListX12TransactionSetsErrorKind::ValidationError(_)
        )
    }
    /// Returns `true` if the error kind is `ListX12TransactionSetsErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(
            &self.kind,
            ListX12TransactionSetsErrorKind::AccessDeniedError(_)
        )
    }
    /// Returns `true` if the error kind is `ListX12TransactionSetsErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(
            &self.kind,
            ListX12TransactionSetsErrorKind::UnauthorizedError(_)
        )
    }
    /// Returns `true` if the error kind is `ListX12TransactionSetsErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(
            &self.kind,
            ListX12TransactionSetsErrorKind::BadRequestError(_)
        )
    }
    /// Returns `true` if the error kind is `ListX12TransactionSetsErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            ListX12TransactionSetsErrorKind::ResourceNotFoundError(_)
        )
    }
}
impl std::error::Error for ListX12TransactionSetsError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListX12TransactionSetsErrorKind::InternalFailureError(_inner) => Some(_inner),
            ListX12TransactionSetsErrorKind::ThrottlingError(_inner) => Some(_inner),
            ListX12TransactionSetsErrorKind::ValidationError(_inner) => Some(_inner),
            ListX12TransactionSetsErrorKind::AccessDeniedError(_inner) => Some(_inner),
            ListX12TransactionSetsErrorKind::UnauthorizedError(_inner) => Some(_inner),
            ListX12TransactionSetsErrorKind::BadRequestError(_inner) => Some(_inner),
            ListX12TransactionSetsErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            ListX12TransactionSetsErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `ListAllPublicGuides` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListAllPublicGuidesError {
    /// Kind of error that occurred.
    pub kind: ListAllPublicGuidesErrorKind,
    /// 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 ListAllPublicGuidesError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: ListAllPublicGuidesErrorKind::Unhandled(crate::error::Unhandled::new(source)),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `ListAllPublicGuides` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListAllPublicGuidesErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// 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 for the request too large error.
    RequestTooLargeError(crate::error::RequestTooLargeError),
    ///
    /// 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 ListAllPublicGuidesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListAllPublicGuidesErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            ListAllPublicGuidesErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            ListAllPublicGuidesErrorKind::ValidationError(_inner) => _inner.fmt(f),
            ListAllPublicGuidesErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            ListAllPublicGuidesErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            ListAllPublicGuidesErrorKind::RequestTooLargeError(_inner) => _inner.fmt(f),
            ListAllPublicGuidesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for ListAllPublicGuidesError {
    fn code(&self) -> Option<&str> {
        ListAllPublicGuidesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            ListAllPublicGuidesErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl ListAllPublicGuidesError {
    /// Creates a new `ListAllPublicGuidesError`.
    pub fn new(kind: ListAllPublicGuidesErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `ListAllPublicGuidesError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListAllPublicGuidesErrorKind::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 `ListAllPublicGuidesErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            ListAllPublicGuidesErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `ListAllPublicGuidesErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(&self.kind, ListAllPublicGuidesErrorKind::ThrottlingError(_))
    }
    /// Returns `true` if the error kind is `ListAllPublicGuidesErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(&self.kind, ListAllPublicGuidesErrorKind::ValidationError(_))
    }
    /// Returns `true` if the error kind is `ListAllPublicGuidesErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(&self.kind, ListAllPublicGuidesErrorKind::BadRequestError(_))
    }
    /// Returns `true` if the error kind is `ListAllPublicGuidesErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            ListAllPublicGuidesErrorKind::ResourceNotFoundError(_)
        )
    }
    /// Returns `true` if the error kind is `ListAllPublicGuidesErrorKind::RequestTooLargeError`.
    pub fn is_request_too_large_error(&self) -> bool {
        matches!(
            &self.kind,
            ListAllPublicGuidesErrorKind::RequestTooLargeError(_)
        )
    }
}
impl std::error::Error for ListAllPublicGuidesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListAllPublicGuidesErrorKind::InternalFailureError(_inner) => Some(_inner),
            ListAllPublicGuidesErrorKind::ThrottlingError(_inner) => Some(_inner),
            ListAllPublicGuidesErrorKind::ValidationError(_inner) => Some(_inner),
            ListAllPublicGuidesErrorKind::BadRequestError(_inner) => Some(_inner),
            ListAllPublicGuidesErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            ListAllPublicGuidesErrorKind::RequestTooLargeError(_inner) => Some(_inner),
            ListAllPublicGuidesErrorKind::Unhandled(_inner) => Some(_inner),
        }
    }
}

/// Error type for the `GetX12TransactionSetMetadata` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct GetX12TransactionSetMetadataError {
    /// Kind of error that occurred.
    pub kind: GetX12TransactionSetMetadataErrorKind,
    /// 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 GetX12TransactionSetMetadataError {
    fn create_unhandled_error(source: Box<dyn std::error::Error + Send + Sync + 'static>) -> Self {
        Self {
            kind: GetX12TransactionSetMetadataErrorKind::Unhandled(crate::error::Unhandled::new(
                source,
            )),
            meta: Default::default(),
        }
    }
}
/// Types of errors that can occur for the `GetX12TransactionSetMetadata` operation.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum GetX12TransactionSetMetadataErrorKind {
    /// The server response when an unexpected error occurred while processing request.
    InternalFailureError(crate::error::InternalFailureError),
    /// The server response when usage plan or account-level throttling limits exceeded.
    ThrottlingError(crate::error::ThrottlingError),
    /// 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),
    /// The server response for authorization failure.
    AccessDeniedError(crate::error::AccessDeniedError),
    /// The server response when the authorizer failed to authenticate the caller.
    UnauthorizedError(crate::error::UnauthorizedError),
    /// The server cannot process the request due to an apparent client error.
    BadRequestError(crate::error::BadRequestError),
    /// The server response when the specified resource cannot be found after an API request passes authentication and authorization.
    ResourceNotFoundError(crate::error::ResourceNotFoundError),
    ///
    /// 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 GetX12TransactionSetMetadataError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            GetX12TransactionSetMetadataErrorKind::InternalFailureError(_inner) => _inner.fmt(f),
            GetX12TransactionSetMetadataErrorKind::ThrottlingError(_inner) => _inner.fmt(f),
            GetX12TransactionSetMetadataErrorKind::ValidationError(_inner) => _inner.fmt(f),
            GetX12TransactionSetMetadataErrorKind::AccessDeniedError(_inner) => _inner.fmt(f),
            GetX12TransactionSetMetadataErrorKind::UnauthorizedError(_inner) => _inner.fmt(f),
            GetX12TransactionSetMetadataErrorKind::BadRequestError(_inner) => _inner.fmt(f),
            GetX12TransactionSetMetadataErrorKind::ResourceNotFoundError(_inner) => _inner.fmt(f),
            GetX12TransactionSetMetadataErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl aws_smithy_types::retry::ProvideErrorKind for GetX12TransactionSetMetadataError {
    fn code(&self) -> Option<&str> {
        GetX12TransactionSetMetadataError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<aws_smithy_types::retry::ErrorKind> {
        match &self.kind {
            GetX12TransactionSetMetadataErrorKind::ThrottlingError(inner) => {
                Some(inner.retryable_error_kind())
            }
            _ => None,
        }
    }
}
impl GetX12TransactionSetMetadataError {
    /// Creates a new `GetX12TransactionSetMetadataError`.
    pub fn new(kind: GetX12TransactionSetMetadataErrorKind, meta: aws_smithy_types::Error) -> Self {
        Self { kind, meta }
    }

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

    /// Creates the `GetX12TransactionSetMetadataError::Unhandled` variant from a `aws_smithy_types::Error`.
    pub fn generic(err: aws_smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: GetX12TransactionSetMetadataErrorKind::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 `GetX12TransactionSetMetadataErrorKind::InternalFailureError`.
    pub fn is_internal_failure_error(&self) -> bool {
        matches!(
            &self.kind,
            GetX12TransactionSetMetadataErrorKind::InternalFailureError(_)
        )
    }
    /// Returns `true` if the error kind is `GetX12TransactionSetMetadataErrorKind::ThrottlingError`.
    pub fn is_throttling_error(&self) -> bool {
        matches!(
            &self.kind,
            GetX12TransactionSetMetadataErrorKind::ThrottlingError(_)
        )
    }
    /// Returns `true` if the error kind is `GetX12TransactionSetMetadataErrorKind::ValidationError`.
    pub fn is_validation_error(&self) -> bool {
        matches!(
            &self.kind,
            GetX12TransactionSetMetadataErrorKind::ValidationError(_)
        )
    }
    /// Returns `true` if the error kind is `GetX12TransactionSetMetadataErrorKind::AccessDeniedError`.
    pub fn is_access_denied_error(&self) -> bool {
        matches!(
            &self.kind,
            GetX12TransactionSetMetadataErrorKind::AccessDeniedError(_)
        )
    }
    /// Returns `true` if the error kind is `GetX12TransactionSetMetadataErrorKind::UnauthorizedError`.
    pub fn is_unauthorized_error(&self) -> bool {
        matches!(
            &self.kind,
            GetX12TransactionSetMetadataErrorKind::UnauthorizedError(_)
        )
    }
    /// Returns `true` if the error kind is `GetX12TransactionSetMetadataErrorKind::BadRequestError`.
    pub fn is_bad_request_error(&self) -> bool {
        matches!(
            &self.kind,
            GetX12TransactionSetMetadataErrorKind::BadRequestError(_)
        )
    }
    /// Returns `true` if the error kind is `GetX12TransactionSetMetadataErrorKind::ResourceNotFoundError`.
    pub fn is_resource_not_found_error(&self) -> bool {
        matches!(
            &self.kind,
            GetX12TransactionSetMetadataErrorKind::ResourceNotFoundError(_)
        )
    }
}
impl std::error::Error for GetX12TransactionSetMetadataError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            GetX12TransactionSetMetadataErrorKind::InternalFailureError(_inner) => Some(_inner),
            GetX12TransactionSetMetadataErrorKind::ThrottlingError(_inner) => Some(_inner),
            GetX12TransactionSetMetadataErrorKind::ValidationError(_inner) => Some(_inner),
            GetX12TransactionSetMetadataErrorKind::AccessDeniedError(_inner) => Some(_inner),
            GetX12TransactionSetMetadataErrorKind::UnauthorizedError(_inner) => Some(_inner),
            GetX12TransactionSetMetadataErrorKind::BadRequestError(_inner) => Some(_inner),
            GetX12TransactionSetMetadataErrorKind::ResourceNotFoundError(_inner) => Some(_inner),
            GetX12TransactionSetMetadataErrorKind::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 _)
    }
}