// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct AssociateEncryptionConfigError {
    pub kind: AssociateEncryptionConfigErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum AssociateEncryptionConfigErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for AssociateEncryptionConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            AssociateEncryptionConfigErrorKind::ClientException(_inner) => _inner.fmt(f),
            AssociateEncryptionConfigErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            AssociateEncryptionConfigErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            AssociateEncryptionConfigErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            AssociateEncryptionConfigErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            AssociateEncryptionConfigErrorKind::ServerException(_inner) => _inner.fmt(f),
            AssociateEncryptionConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for AssociateEncryptionConfigError {
    fn code(&self) -> Option<&str> {
        AssociateEncryptionConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl AssociateEncryptionConfigError {
    pub fn new(kind: AssociateEncryptionConfigErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: AssociateEncryptionConfigErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: AssociateEncryptionConfigErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateEncryptionConfigErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateEncryptionConfigErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateEncryptionConfigErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateEncryptionConfigErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateEncryptionConfigErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateEncryptionConfigErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for AssociateEncryptionConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            AssociateEncryptionConfigErrorKind::ClientException(_inner) => Some(_inner),
            AssociateEncryptionConfigErrorKind::InvalidParameterException(_inner) => Some(_inner),
            AssociateEncryptionConfigErrorKind::InvalidRequestException(_inner) => Some(_inner),
            AssociateEncryptionConfigErrorKind::ResourceInUseException(_inner) => Some(_inner),
            AssociateEncryptionConfigErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            AssociateEncryptionConfigErrorKind::ServerException(_inner) => Some(_inner),
            AssociateEncryptionConfigErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct AssociateIdentityProviderConfigError {
    pub kind: AssociateIdentityProviderConfigErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum AssociateIdentityProviderConfigErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for AssociateIdentityProviderConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            AssociateIdentityProviderConfigErrorKind::ClientException(_inner) => _inner.fmt(f),
            AssociateIdentityProviderConfigErrorKind::InvalidParameterException(_inner) => {
                _inner.fmt(f)
            }
            AssociateIdentityProviderConfigErrorKind::InvalidRequestException(_inner) => {
                _inner.fmt(f)
            }
            AssociateIdentityProviderConfigErrorKind::ResourceInUseException(_inner) => {
                _inner.fmt(f)
            }
            AssociateIdentityProviderConfigErrorKind::ResourceNotFoundException(_inner) => {
                _inner.fmt(f)
            }
            AssociateIdentityProviderConfigErrorKind::ServerException(_inner) => _inner.fmt(f),
            AssociateIdentityProviderConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for AssociateIdentityProviderConfigError {
    fn code(&self) -> Option<&str> {
        AssociateIdentityProviderConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl AssociateIdentityProviderConfigError {
    pub fn new(kind: AssociateIdentityProviderConfigErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: AssociateIdentityProviderConfigErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: AssociateIdentityProviderConfigErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateIdentityProviderConfigErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateIdentityProviderConfigErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateIdentityProviderConfigErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateIdentityProviderConfigErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateIdentityProviderConfigErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            AssociateIdentityProviderConfigErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for AssociateIdentityProviderConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            AssociateIdentityProviderConfigErrorKind::ClientException(_inner) => Some(_inner),
            AssociateIdentityProviderConfigErrorKind::InvalidParameterException(_inner) => {
                Some(_inner)
            }
            AssociateIdentityProviderConfigErrorKind::InvalidRequestException(_inner) => {
                Some(_inner)
            }
            AssociateIdentityProviderConfigErrorKind::ResourceInUseException(_inner) => {
                Some(_inner)
            }
            AssociateIdentityProviderConfigErrorKind::ResourceNotFoundException(_inner) => {
                Some(_inner)
            }
            AssociateIdentityProviderConfigErrorKind::ServerException(_inner) => Some(_inner),
            AssociateIdentityProviderConfigErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateAddonError {
    pub kind: CreateAddonErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateAddonErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for CreateAddonError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            CreateAddonErrorKind::ClientException(_inner) => _inner.fmt(f),
            CreateAddonErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            CreateAddonErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            CreateAddonErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            CreateAddonErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            CreateAddonErrorKind::ServerException(_inner) => _inner.fmt(f),
            CreateAddonErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for CreateAddonError {
    fn code(&self) -> Option<&str> {
        CreateAddonError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl CreateAddonError {
    pub fn new(kind: CreateAddonErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: CreateAddonErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: CreateAddonErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, CreateAddonErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateAddonErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(&self.kind, CreateAddonErrorKind::InvalidRequestException(_))
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(&self.kind, CreateAddonErrorKind::ResourceInUseException(_))
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateAddonErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, CreateAddonErrorKind::ServerException(_))
    }
}
impl std::error::Error for CreateAddonError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            CreateAddonErrorKind::ClientException(_inner) => Some(_inner),
            CreateAddonErrorKind::InvalidParameterException(_inner) => Some(_inner),
            CreateAddonErrorKind::InvalidRequestException(_inner) => Some(_inner),
            CreateAddonErrorKind::ResourceInUseException(_inner) => Some(_inner),
            CreateAddonErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            CreateAddonErrorKind::ServerException(_inner) => Some(_inner),
            CreateAddonErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateClusterError {
    pub kind: CreateClusterErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateClusterErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceLimitExceededException(crate::error::ResourceLimitExceededException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    UnsupportedAvailabilityZoneException(crate::error::UnsupportedAvailabilityZoneException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for CreateClusterError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            CreateClusterErrorKind::ClientException(_inner) => _inner.fmt(f),
            CreateClusterErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            CreateClusterErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            CreateClusterErrorKind::ResourceLimitExceededException(_inner) => _inner.fmt(f),
            CreateClusterErrorKind::ServerException(_inner) => _inner.fmt(f),
            CreateClusterErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            CreateClusterErrorKind::UnsupportedAvailabilityZoneException(_inner) => _inner.fmt(f),
            CreateClusterErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for CreateClusterError {
    fn code(&self) -> Option<&str> {
        CreateClusterError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl CreateClusterError {
    pub fn new(kind: CreateClusterErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: CreateClusterErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: CreateClusterErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, CreateClusterErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateClusterErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateClusterErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_limit_exceeded_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateClusterErrorKind::ResourceLimitExceededException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, CreateClusterErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateClusterErrorKind::ServiceUnavailableException(_)
        )
    }
    pub fn is_unsupported_availability_zone_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateClusterErrorKind::UnsupportedAvailabilityZoneException(_)
        )
    }
}
impl std::error::Error for CreateClusterError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            CreateClusterErrorKind::ClientException(_inner) => Some(_inner),
            CreateClusterErrorKind::InvalidParameterException(_inner) => Some(_inner),
            CreateClusterErrorKind::ResourceInUseException(_inner) => Some(_inner),
            CreateClusterErrorKind::ResourceLimitExceededException(_inner) => Some(_inner),
            CreateClusterErrorKind::ServerException(_inner) => Some(_inner),
            CreateClusterErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            CreateClusterErrorKind::UnsupportedAvailabilityZoneException(_inner) => Some(_inner),
            CreateClusterErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateFargateProfileError {
    pub kind: CreateFargateProfileErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateFargateProfileErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceLimitExceededException(crate::error::ResourceLimitExceededException),
    ServerException(crate::error::ServerException),
    UnsupportedAvailabilityZoneException(crate::error::UnsupportedAvailabilityZoneException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for CreateFargateProfileError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            CreateFargateProfileErrorKind::ClientException(_inner) => _inner.fmt(f),
            CreateFargateProfileErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            CreateFargateProfileErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            CreateFargateProfileErrorKind::ResourceLimitExceededException(_inner) => _inner.fmt(f),
            CreateFargateProfileErrorKind::ServerException(_inner) => _inner.fmt(f),
            CreateFargateProfileErrorKind::UnsupportedAvailabilityZoneException(_inner) => {
                _inner.fmt(f)
            }
            CreateFargateProfileErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for CreateFargateProfileError {
    fn code(&self) -> Option<&str> {
        CreateFargateProfileError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl CreateFargateProfileError {
    pub fn new(kind: CreateFargateProfileErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: CreateFargateProfileErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: CreateFargateProfileErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateFargateProfileErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateFargateProfileErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateFargateProfileErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_limit_exceeded_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateFargateProfileErrorKind::ResourceLimitExceededException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateFargateProfileErrorKind::ServerException(_)
        )
    }
    pub fn is_unsupported_availability_zone_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateFargateProfileErrorKind::UnsupportedAvailabilityZoneException(_)
        )
    }
}
impl std::error::Error for CreateFargateProfileError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            CreateFargateProfileErrorKind::ClientException(_inner) => Some(_inner),
            CreateFargateProfileErrorKind::InvalidParameterException(_inner) => Some(_inner),
            CreateFargateProfileErrorKind::InvalidRequestException(_inner) => Some(_inner),
            CreateFargateProfileErrorKind::ResourceLimitExceededException(_inner) => Some(_inner),
            CreateFargateProfileErrorKind::ServerException(_inner) => Some(_inner),
            CreateFargateProfileErrorKind::UnsupportedAvailabilityZoneException(_inner) => {
                Some(_inner)
            }
            CreateFargateProfileErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct CreateNodegroupError {
    pub kind: CreateNodegroupErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum CreateNodegroupErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceLimitExceededException(crate::error::ResourceLimitExceededException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for CreateNodegroupError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            CreateNodegroupErrorKind::ClientException(_inner) => _inner.fmt(f),
            CreateNodegroupErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            CreateNodegroupErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            CreateNodegroupErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            CreateNodegroupErrorKind::ResourceLimitExceededException(_inner) => _inner.fmt(f),
            CreateNodegroupErrorKind::ServerException(_inner) => _inner.fmt(f),
            CreateNodegroupErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            CreateNodegroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for CreateNodegroupError {
    fn code(&self) -> Option<&str> {
        CreateNodegroupError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl CreateNodegroupError {
    pub fn new(kind: CreateNodegroupErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: CreateNodegroupErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: CreateNodegroupErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, CreateNodegroupErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateNodegroupErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateNodegroupErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateNodegroupErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_limit_exceeded_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateNodegroupErrorKind::ResourceLimitExceededException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, CreateNodegroupErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            CreateNodegroupErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for CreateNodegroupError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            CreateNodegroupErrorKind::ClientException(_inner) => Some(_inner),
            CreateNodegroupErrorKind::InvalidParameterException(_inner) => Some(_inner),
            CreateNodegroupErrorKind::InvalidRequestException(_inner) => Some(_inner),
            CreateNodegroupErrorKind::ResourceInUseException(_inner) => Some(_inner),
            CreateNodegroupErrorKind::ResourceLimitExceededException(_inner) => Some(_inner),
            CreateNodegroupErrorKind::ServerException(_inner) => Some(_inner),
            CreateNodegroupErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            CreateNodegroupErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteAddonError {
    pub kind: DeleteAddonErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteAddonErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DeleteAddonError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DeleteAddonErrorKind::ClientException(_inner) => _inner.fmt(f),
            DeleteAddonErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DeleteAddonErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            DeleteAddonErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DeleteAddonErrorKind::ServerException(_inner) => _inner.fmt(f),
            DeleteAddonErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DeleteAddonError {
    fn code(&self) -> Option<&str> {
        DeleteAddonError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DeleteAddonError {
    pub fn new(kind: DeleteAddonErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DeleteAddonErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DeleteAddonErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, DeleteAddonErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteAddonErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(&self.kind, DeleteAddonErrorKind::InvalidRequestException(_))
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteAddonErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, DeleteAddonErrorKind::ServerException(_))
    }
}
impl std::error::Error for DeleteAddonError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DeleteAddonErrorKind::ClientException(_inner) => Some(_inner),
            DeleteAddonErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DeleteAddonErrorKind::InvalidRequestException(_inner) => Some(_inner),
            DeleteAddonErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DeleteAddonErrorKind::ServerException(_inner) => Some(_inner),
            DeleteAddonErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteClusterError {
    pub kind: DeleteClusterErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteClusterErrorKind {
    ClientException(crate::error::ClientException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DeleteClusterError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DeleteClusterErrorKind::ClientException(_inner) => _inner.fmt(f),
            DeleteClusterErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            DeleteClusterErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DeleteClusterErrorKind::ServerException(_inner) => _inner.fmt(f),
            DeleteClusterErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            DeleteClusterErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DeleteClusterError {
    fn code(&self) -> Option<&str> {
        DeleteClusterError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DeleteClusterError {
    pub fn new(kind: DeleteClusterErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DeleteClusterErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DeleteClusterErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, DeleteClusterErrorKind::ClientException(_))
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteClusterErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteClusterErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, DeleteClusterErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteClusterErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for DeleteClusterError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DeleteClusterErrorKind::ClientException(_inner) => Some(_inner),
            DeleteClusterErrorKind::ResourceInUseException(_inner) => Some(_inner),
            DeleteClusterErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DeleteClusterErrorKind::ServerException(_inner) => Some(_inner),
            DeleteClusterErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            DeleteClusterErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteFargateProfileError {
    pub kind: DeleteFargateProfileErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteFargateProfileErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DeleteFargateProfileError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DeleteFargateProfileErrorKind::ClientException(_inner) => _inner.fmt(f),
            DeleteFargateProfileErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DeleteFargateProfileErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DeleteFargateProfileErrorKind::ServerException(_inner) => _inner.fmt(f),
            DeleteFargateProfileErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DeleteFargateProfileError {
    fn code(&self) -> Option<&str> {
        DeleteFargateProfileError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DeleteFargateProfileError {
    pub fn new(kind: DeleteFargateProfileErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DeleteFargateProfileErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DeleteFargateProfileErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteFargateProfileErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteFargateProfileErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteFargateProfileErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteFargateProfileErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for DeleteFargateProfileError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DeleteFargateProfileErrorKind::ClientException(_inner) => Some(_inner),
            DeleteFargateProfileErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DeleteFargateProfileErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DeleteFargateProfileErrorKind::ServerException(_inner) => Some(_inner),
            DeleteFargateProfileErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DeleteNodegroupError {
    pub kind: DeleteNodegroupErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DeleteNodegroupErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DeleteNodegroupError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DeleteNodegroupErrorKind::ClientException(_inner) => _inner.fmt(f),
            DeleteNodegroupErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DeleteNodegroupErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            DeleteNodegroupErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DeleteNodegroupErrorKind::ServerException(_inner) => _inner.fmt(f),
            DeleteNodegroupErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            DeleteNodegroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DeleteNodegroupError {
    fn code(&self) -> Option<&str> {
        DeleteNodegroupError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DeleteNodegroupError {
    pub fn new(kind: DeleteNodegroupErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DeleteNodegroupErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DeleteNodegroupErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, DeleteNodegroupErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteNodegroupErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteNodegroupErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteNodegroupErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, DeleteNodegroupErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            DeleteNodegroupErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for DeleteNodegroupError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DeleteNodegroupErrorKind::ClientException(_inner) => Some(_inner),
            DeleteNodegroupErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DeleteNodegroupErrorKind::ResourceInUseException(_inner) => Some(_inner),
            DeleteNodegroupErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DeleteNodegroupErrorKind::ServerException(_inner) => Some(_inner),
            DeleteNodegroupErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            DeleteNodegroupErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeAddonError {
    pub kind: DescribeAddonErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeAddonErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DescribeAddonError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DescribeAddonErrorKind::ClientException(_inner) => _inner.fmt(f),
            DescribeAddonErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DescribeAddonErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            DescribeAddonErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DescribeAddonErrorKind::ServerException(_inner) => _inner.fmt(f),
            DescribeAddonErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DescribeAddonError {
    fn code(&self) -> Option<&str> {
        DescribeAddonError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DescribeAddonError {
    pub fn new(kind: DescribeAddonErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DescribeAddonErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DescribeAddonErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, DescribeAddonErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeAddonErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeAddonErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeAddonErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, DescribeAddonErrorKind::ServerException(_))
    }
}
impl std::error::Error for DescribeAddonError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DescribeAddonErrorKind::ClientException(_inner) => Some(_inner),
            DescribeAddonErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DescribeAddonErrorKind::InvalidRequestException(_inner) => Some(_inner),
            DescribeAddonErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DescribeAddonErrorKind::ServerException(_inner) => Some(_inner),
            DescribeAddonErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeAddonVersionsError {
    pub kind: DescribeAddonVersionsErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeAddonVersionsErrorKind {
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DescribeAddonVersionsError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DescribeAddonVersionsErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DescribeAddonVersionsErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DescribeAddonVersionsErrorKind::ServerException(_inner) => _inner.fmt(f),
            DescribeAddonVersionsErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DescribeAddonVersionsError {
    fn code(&self) -> Option<&str> {
        DescribeAddonVersionsError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DescribeAddonVersionsError {
    pub fn new(kind: DescribeAddonVersionsErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DescribeAddonVersionsErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DescribeAddonVersionsErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeAddonVersionsErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeAddonVersionsErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeAddonVersionsErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for DescribeAddonVersionsError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DescribeAddonVersionsErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DescribeAddonVersionsErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DescribeAddonVersionsErrorKind::ServerException(_inner) => Some(_inner),
            DescribeAddonVersionsErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeClusterError {
    pub kind: DescribeClusterErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeClusterErrorKind {
    ClientException(crate::error::ClientException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DescribeClusterError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DescribeClusterErrorKind::ClientException(_inner) => _inner.fmt(f),
            DescribeClusterErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DescribeClusterErrorKind::ServerException(_inner) => _inner.fmt(f),
            DescribeClusterErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            DescribeClusterErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DescribeClusterError {
    fn code(&self) -> Option<&str> {
        DescribeClusterError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DescribeClusterError {
    pub fn new(kind: DescribeClusterErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DescribeClusterErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DescribeClusterErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, DescribeClusterErrorKind::ClientException(_))
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeClusterErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, DescribeClusterErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeClusterErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for DescribeClusterError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DescribeClusterErrorKind::ClientException(_inner) => Some(_inner),
            DescribeClusterErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DescribeClusterErrorKind::ServerException(_inner) => Some(_inner),
            DescribeClusterErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            DescribeClusterErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeFargateProfileError {
    pub kind: DescribeFargateProfileErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeFargateProfileErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DescribeFargateProfileError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DescribeFargateProfileErrorKind::ClientException(_inner) => _inner.fmt(f),
            DescribeFargateProfileErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DescribeFargateProfileErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DescribeFargateProfileErrorKind::ServerException(_inner) => _inner.fmt(f),
            DescribeFargateProfileErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DescribeFargateProfileError {
    fn code(&self) -> Option<&str> {
        DescribeFargateProfileError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DescribeFargateProfileError {
    pub fn new(kind: DescribeFargateProfileErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DescribeFargateProfileErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DescribeFargateProfileErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeFargateProfileErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeFargateProfileErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeFargateProfileErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeFargateProfileErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for DescribeFargateProfileError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DescribeFargateProfileErrorKind::ClientException(_inner) => Some(_inner),
            DescribeFargateProfileErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DescribeFargateProfileErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DescribeFargateProfileErrorKind::ServerException(_inner) => Some(_inner),
            DescribeFargateProfileErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeIdentityProviderConfigError {
    pub kind: DescribeIdentityProviderConfigErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeIdentityProviderConfigErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DescribeIdentityProviderConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DescribeIdentityProviderConfigErrorKind::ClientException(_inner) => _inner.fmt(f),
            DescribeIdentityProviderConfigErrorKind::InvalidParameterException(_inner) => {
                _inner.fmt(f)
            }
            DescribeIdentityProviderConfigErrorKind::ResourceNotFoundException(_inner) => {
                _inner.fmt(f)
            }
            DescribeIdentityProviderConfigErrorKind::ServerException(_inner) => _inner.fmt(f),
            DescribeIdentityProviderConfigErrorKind::ServiceUnavailableException(_inner) => {
                _inner.fmt(f)
            }
            DescribeIdentityProviderConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DescribeIdentityProviderConfigError {
    fn code(&self) -> Option<&str> {
        DescribeIdentityProviderConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DescribeIdentityProviderConfigError {
    pub fn new(kind: DescribeIdentityProviderConfigErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DescribeIdentityProviderConfigErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DescribeIdentityProviderConfigErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeIdentityProviderConfigErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeIdentityProviderConfigErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeIdentityProviderConfigErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeIdentityProviderConfigErrorKind::ServerException(_)
        )
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeIdentityProviderConfigErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for DescribeIdentityProviderConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DescribeIdentityProviderConfigErrorKind::ClientException(_inner) => Some(_inner),
            DescribeIdentityProviderConfigErrorKind::InvalidParameterException(_inner) => {
                Some(_inner)
            }
            DescribeIdentityProviderConfigErrorKind::ResourceNotFoundException(_inner) => {
                Some(_inner)
            }
            DescribeIdentityProviderConfigErrorKind::ServerException(_inner) => Some(_inner),
            DescribeIdentityProviderConfigErrorKind::ServiceUnavailableException(_inner) => {
                Some(_inner)
            }
            DescribeIdentityProviderConfigErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeNodegroupError {
    pub kind: DescribeNodegroupErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeNodegroupErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DescribeNodegroupError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DescribeNodegroupErrorKind::ClientException(_inner) => _inner.fmt(f),
            DescribeNodegroupErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DescribeNodegroupErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DescribeNodegroupErrorKind::ServerException(_inner) => _inner.fmt(f),
            DescribeNodegroupErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            DescribeNodegroupErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DescribeNodegroupError {
    fn code(&self) -> Option<&str> {
        DescribeNodegroupError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DescribeNodegroupError {
    pub fn new(kind: DescribeNodegroupErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DescribeNodegroupErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DescribeNodegroupErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, DescribeNodegroupErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeNodegroupErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeNodegroupErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, DescribeNodegroupErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeNodegroupErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for DescribeNodegroupError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DescribeNodegroupErrorKind::ClientException(_inner) => Some(_inner),
            DescribeNodegroupErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DescribeNodegroupErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DescribeNodegroupErrorKind::ServerException(_inner) => Some(_inner),
            DescribeNodegroupErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            DescribeNodegroupErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DescribeUpdateError {
    pub kind: DescribeUpdateErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DescribeUpdateErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DescribeUpdateError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DescribeUpdateErrorKind::ClientException(_inner) => _inner.fmt(f),
            DescribeUpdateErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            DescribeUpdateErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            DescribeUpdateErrorKind::ServerException(_inner) => _inner.fmt(f),
            DescribeUpdateErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DescribeUpdateError {
    fn code(&self) -> Option<&str> {
        DescribeUpdateError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DescribeUpdateError {
    pub fn new(kind: DescribeUpdateErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DescribeUpdateErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DescribeUpdateErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, DescribeUpdateErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeUpdateErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DescribeUpdateErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, DescribeUpdateErrorKind::ServerException(_))
    }
}
impl std::error::Error for DescribeUpdateError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DescribeUpdateErrorKind::ClientException(_inner) => Some(_inner),
            DescribeUpdateErrorKind::InvalidParameterException(_inner) => Some(_inner),
            DescribeUpdateErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            DescribeUpdateErrorKind::ServerException(_inner) => Some(_inner),
            DescribeUpdateErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct DisassociateIdentityProviderConfigError {
    pub kind: DisassociateIdentityProviderConfigErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum DisassociateIdentityProviderConfigErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for DisassociateIdentityProviderConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            DisassociateIdentityProviderConfigErrorKind::ClientException(_inner) => _inner.fmt(f),
            DisassociateIdentityProviderConfigErrorKind::InvalidParameterException(_inner) => {
                _inner.fmt(f)
            }
            DisassociateIdentityProviderConfigErrorKind::InvalidRequestException(_inner) => {
                _inner.fmt(f)
            }
            DisassociateIdentityProviderConfigErrorKind::ResourceInUseException(_inner) => {
                _inner.fmt(f)
            }
            DisassociateIdentityProviderConfigErrorKind::ResourceNotFoundException(_inner) => {
                _inner.fmt(f)
            }
            DisassociateIdentityProviderConfigErrorKind::ServerException(_inner) => _inner.fmt(f),
            DisassociateIdentityProviderConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for DisassociateIdentityProviderConfigError {
    fn code(&self) -> Option<&str> {
        DisassociateIdentityProviderConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl DisassociateIdentityProviderConfigError {
    pub fn new(
        kind: DisassociateIdentityProviderConfigErrorKind,
        meta: smithy_types::Error,
    ) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: DisassociateIdentityProviderConfigErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: DisassociateIdentityProviderConfigErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            DisassociateIdentityProviderConfigErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            DisassociateIdentityProviderConfigErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            DisassociateIdentityProviderConfigErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            DisassociateIdentityProviderConfigErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            DisassociateIdentityProviderConfigErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            DisassociateIdentityProviderConfigErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for DisassociateIdentityProviderConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            DisassociateIdentityProviderConfigErrorKind::ClientException(_inner) => Some(_inner),
            DisassociateIdentityProviderConfigErrorKind::InvalidParameterException(_inner) => {
                Some(_inner)
            }
            DisassociateIdentityProviderConfigErrorKind::InvalidRequestException(_inner) => {
                Some(_inner)
            }
            DisassociateIdentityProviderConfigErrorKind::ResourceInUseException(_inner) => {
                Some(_inner)
            }
            DisassociateIdentityProviderConfigErrorKind::ResourceNotFoundException(_inner) => {
                Some(_inner)
            }
            DisassociateIdentityProviderConfigErrorKind::ServerException(_inner) => Some(_inner),
            DisassociateIdentityProviderConfigErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListAddonsError {
    pub kind: ListAddonsErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListAddonsErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for ListAddonsError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListAddonsErrorKind::ClientException(_inner) => _inner.fmt(f),
            ListAddonsErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            ListAddonsErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            ListAddonsErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            ListAddonsErrorKind::ServerException(_inner) => _inner.fmt(f),
            ListAddonsErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for ListAddonsError {
    fn code(&self) -> Option<&str> {
        ListAddonsError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl ListAddonsError {
    pub fn new(kind: ListAddonsErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: ListAddonsErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListAddonsErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, ListAddonsErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListAddonsErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(&self.kind, ListAddonsErrorKind::InvalidRequestException(_))
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListAddonsErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, ListAddonsErrorKind::ServerException(_))
    }
}
impl std::error::Error for ListAddonsError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListAddonsErrorKind::ClientException(_inner) => Some(_inner),
            ListAddonsErrorKind::InvalidParameterException(_inner) => Some(_inner),
            ListAddonsErrorKind::InvalidRequestException(_inner) => Some(_inner),
            ListAddonsErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            ListAddonsErrorKind::ServerException(_inner) => Some(_inner),
            ListAddonsErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListClustersError {
    pub kind: ListClustersErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListClustersErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for ListClustersError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListClustersErrorKind::ClientException(_inner) => _inner.fmt(f),
            ListClustersErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            ListClustersErrorKind::ServerException(_inner) => _inner.fmt(f),
            ListClustersErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            ListClustersErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for ListClustersError {
    fn code(&self) -> Option<&str> {
        ListClustersError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl ListClustersError {
    pub fn new(kind: ListClustersErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: ListClustersErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListClustersErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, ListClustersErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListClustersErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, ListClustersErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListClustersErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for ListClustersError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListClustersErrorKind::ClientException(_inner) => Some(_inner),
            ListClustersErrorKind::InvalidParameterException(_inner) => Some(_inner),
            ListClustersErrorKind::ServerException(_inner) => Some(_inner),
            ListClustersErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            ListClustersErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListFargateProfilesError {
    pub kind: ListFargateProfilesErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListFargateProfilesErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for ListFargateProfilesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListFargateProfilesErrorKind::ClientException(_inner) => _inner.fmt(f),
            ListFargateProfilesErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            ListFargateProfilesErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            ListFargateProfilesErrorKind::ServerException(_inner) => _inner.fmt(f),
            ListFargateProfilesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for ListFargateProfilesError {
    fn code(&self) -> Option<&str> {
        ListFargateProfilesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl ListFargateProfilesError {
    pub fn new(kind: ListFargateProfilesErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: ListFargateProfilesErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListFargateProfilesErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, ListFargateProfilesErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListFargateProfilesErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListFargateProfilesErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, ListFargateProfilesErrorKind::ServerException(_))
    }
}
impl std::error::Error for ListFargateProfilesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListFargateProfilesErrorKind::ClientException(_inner) => Some(_inner),
            ListFargateProfilesErrorKind::InvalidParameterException(_inner) => Some(_inner),
            ListFargateProfilesErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            ListFargateProfilesErrorKind::ServerException(_inner) => Some(_inner),
            ListFargateProfilesErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListIdentityProviderConfigsError {
    pub kind: ListIdentityProviderConfigsErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListIdentityProviderConfigsErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for ListIdentityProviderConfigsError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListIdentityProviderConfigsErrorKind::ClientException(_inner) => _inner.fmt(f),
            ListIdentityProviderConfigsErrorKind::InvalidParameterException(_inner) => {
                _inner.fmt(f)
            }
            ListIdentityProviderConfigsErrorKind::ResourceNotFoundException(_inner) => {
                _inner.fmt(f)
            }
            ListIdentityProviderConfigsErrorKind::ServerException(_inner) => _inner.fmt(f),
            ListIdentityProviderConfigsErrorKind::ServiceUnavailableException(_inner) => {
                _inner.fmt(f)
            }
            ListIdentityProviderConfigsErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for ListIdentityProviderConfigsError {
    fn code(&self) -> Option<&str> {
        ListIdentityProviderConfigsError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl ListIdentityProviderConfigsError {
    pub fn new(kind: ListIdentityProviderConfigsErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: ListIdentityProviderConfigsErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListIdentityProviderConfigsErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListIdentityProviderConfigsErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListIdentityProviderConfigsErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListIdentityProviderConfigsErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListIdentityProviderConfigsErrorKind::ServerException(_)
        )
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListIdentityProviderConfigsErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for ListIdentityProviderConfigsError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListIdentityProviderConfigsErrorKind::ClientException(_inner) => Some(_inner),
            ListIdentityProviderConfigsErrorKind::InvalidParameterException(_inner) => Some(_inner),
            ListIdentityProviderConfigsErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            ListIdentityProviderConfigsErrorKind::ServerException(_inner) => Some(_inner),
            ListIdentityProviderConfigsErrorKind::ServiceUnavailableException(_inner) => {
                Some(_inner)
            }
            ListIdentityProviderConfigsErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListNodegroupsError {
    pub kind: ListNodegroupsErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListNodegroupsErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for ListNodegroupsError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListNodegroupsErrorKind::ClientException(_inner) => _inner.fmt(f),
            ListNodegroupsErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            ListNodegroupsErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            ListNodegroupsErrorKind::ServerException(_inner) => _inner.fmt(f),
            ListNodegroupsErrorKind::ServiceUnavailableException(_inner) => _inner.fmt(f),
            ListNodegroupsErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for ListNodegroupsError {
    fn code(&self) -> Option<&str> {
        ListNodegroupsError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl ListNodegroupsError {
    pub fn new(kind: ListNodegroupsErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: ListNodegroupsErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListNodegroupsErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, ListNodegroupsErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListNodegroupsErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListNodegroupsErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, ListNodegroupsErrorKind::ServerException(_))
    }
    pub fn is_service_unavailable_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListNodegroupsErrorKind::ServiceUnavailableException(_)
        )
    }
}
impl std::error::Error for ListNodegroupsError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListNodegroupsErrorKind::ClientException(_inner) => Some(_inner),
            ListNodegroupsErrorKind::InvalidParameterException(_inner) => Some(_inner),
            ListNodegroupsErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            ListNodegroupsErrorKind::ServerException(_inner) => Some(_inner),
            ListNodegroupsErrorKind::ServiceUnavailableException(_inner) => Some(_inner),
            ListNodegroupsErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListTagsForResourceError {
    pub kind: ListTagsForResourceErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListTagsForResourceErrorKind {
    BadRequestException(crate::error::BadRequestException),
    NotFoundException(crate::error::NotFoundException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for ListTagsForResourceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListTagsForResourceErrorKind::BadRequestException(_inner) => _inner.fmt(f),
            ListTagsForResourceErrorKind::NotFoundException(_inner) => _inner.fmt(f),
            ListTagsForResourceErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for ListTagsForResourceError {
    fn code(&self) -> Option<&str> {
        ListTagsForResourceError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl ListTagsForResourceError {
    pub fn new(kind: ListTagsForResourceErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: ListTagsForResourceErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListTagsForResourceErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_bad_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListTagsForResourceErrorKind::BadRequestException(_)
        )
    }
    pub fn is_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListTagsForResourceErrorKind::NotFoundException(_)
        )
    }
}
impl std::error::Error for ListTagsForResourceError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListTagsForResourceErrorKind::BadRequestException(_inner) => Some(_inner),
            ListTagsForResourceErrorKind::NotFoundException(_inner) => Some(_inner),
            ListTagsForResourceErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct ListUpdatesError {
    pub kind: ListUpdatesErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum ListUpdatesErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for ListUpdatesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            ListUpdatesErrorKind::ClientException(_inner) => _inner.fmt(f),
            ListUpdatesErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            ListUpdatesErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            ListUpdatesErrorKind::ServerException(_inner) => _inner.fmt(f),
            ListUpdatesErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for ListUpdatesError {
    fn code(&self) -> Option<&str> {
        ListUpdatesError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl ListUpdatesError {
    pub fn new(kind: ListUpdatesErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: ListUpdatesErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: ListUpdatesErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, ListUpdatesErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListUpdatesErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            ListUpdatesErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, ListUpdatesErrorKind::ServerException(_))
    }
}
impl std::error::Error for ListUpdatesError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            ListUpdatesErrorKind::ClientException(_inner) => Some(_inner),
            ListUpdatesErrorKind::InvalidParameterException(_inner) => Some(_inner),
            ListUpdatesErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            ListUpdatesErrorKind::ServerException(_inner) => Some(_inner),
            ListUpdatesErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct TagResourceError {
    pub kind: TagResourceErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum TagResourceErrorKind {
    BadRequestException(crate::error::BadRequestException),
    NotFoundException(crate::error::NotFoundException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for TagResourceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            TagResourceErrorKind::BadRequestException(_inner) => _inner.fmt(f),
            TagResourceErrorKind::NotFoundException(_inner) => _inner.fmt(f),
            TagResourceErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for TagResourceError {
    fn code(&self) -> Option<&str> {
        TagResourceError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl TagResourceError {
    pub fn new(kind: TagResourceErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: TagResourceErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: TagResourceErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_bad_request_exception(&self) -> bool {
        matches!(&self.kind, TagResourceErrorKind::BadRequestException(_))
    }
    pub fn is_not_found_exception(&self) -> bool {
        matches!(&self.kind, TagResourceErrorKind::NotFoundException(_))
    }
}
impl std::error::Error for TagResourceError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            TagResourceErrorKind::BadRequestException(_inner) => Some(_inner),
            TagResourceErrorKind::NotFoundException(_inner) => Some(_inner),
            TagResourceErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UntagResourceError {
    pub kind: UntagResourceErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UntagResourceErrorKind {
    BadRequestException(crate::error::BadRequestException),
    NotFoundException(crate::error::NotFoundException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for UntagResourceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UntagResourceErrorKind::BadRequestException(_inner) => _inner.fmt(f),
            UntagResourceErrorKind::NotFoundException(_inner) => _inner.fmt(f),
            UntagResourceErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for UntagResourceError {
    fn code(&self) -> Option<&str> {
        UntagResourceError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl UntagResourceError {
    pub fn new(kind: UntagResourceErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: UntagResourceErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UntagResourceErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_bad_request_exception(&self) -> bool {
        matches!(&self.kind, UntagResourceErrorKind::BadRequestException(_))
    }
    pub fn is_not_found_exception(&self) -> bool {
        matches!(&self.kind, UntagResourceErrorKind::NotFoundException(_))
    }
}
impl std::error::Error for UntagResourceError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UntagResourceErrorKind::BadRequestException(_inner) => Some(_inner),
            UntagResourceErrorKind::NotFoundException(_inner) => Some(_inner),
            UntagResourceErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateAddonError {
    pub kind: UpdateAddonErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateAddonErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for UpdateAddonError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateAddonErrorKind::ClientException(_inner) => _inner.fmt(f),
            UpdateAddonErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            UpdateAddonErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            UpdateAddonErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            UpdateAddonErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            UpdateAddonErrorKind::ServerException(_inner) => _inner.fmt(f),
            UpdateAddonErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for UpdateAddonError {
    fn code(&self) -> Option<&str> {
        UpdateAddonError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl UpdateAddonError {
    pub fn new(kind: UpdateAddonErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: UpdateAddonErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateAddonErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, UpdateAddonErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAddonErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(&self.kind, UpdateAddonErrorKind::InvalidRequestException(_))
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(&self.kind, UpdateAddonErrorKind::ResourceInUseException(_))
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateAddonErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, UpdateAddonErrorKind::ServerException(_))
    }
}
impl std::error::Error for UpdateAddonError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateAddonErrorKind::ClientException(_inner) => Some(_inner),
            UpdateAddonErrorKind::InvalidParameterException(_inner) => Some(_inner),
            UpdateAddonErrorKind::InvalidRequestException(_inner) => Some(_inner),
            UpdateAddonErrorKind::ResourceInUseException(_inner) => Some(_inner),
            UpdateAddonErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            UpdateAddonErrorKind::ServerException(_inner) => Some(_inner),
            UpdateAddonErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateClusterConfigError {
    pub kind: UpdateClusterConfigErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateClusterConfigErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for UpdateClusterConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateClusterConfigErrorKind::ClientException(_inner) => _inner.fmt(f),
            UpdateClusterConfigErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            UpdateClusterConfigErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            UpdateClusterConfigErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            UpdateClusterConfigErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            UpdateClusterConfigErrorKind::ServerException(_inner) => _inner.fmt(f),
            UpdateClusterConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for UpdateClusterConfigError {
    fn code(&self) -> Option<&str> {
        UpdateClusterConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl UpdateClusterConfigError {
    pub fn new(kind: UpdateClusterConfigErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: UpdateClusterConfigErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateClusterConfigErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(&self.kind, UpdateClusterConfigErrorKind::ClientException(_))
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterConfigErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterConfigErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterConfigErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterConfigErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(&self.kind, UpdateClusterConfigErrorKind::ServerException(_))
    }
}
impl std::error::Error for UpdateClusterConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateClusterConfigErrorKind::ClientException(_inner) => Some(_inner),
            UpdateClusterConfigErrorKind::InvalidParameterException(_inner) => Some(_inner),
            UpdateClusterConfigErrorKind::InvalidRequestException(_inner) => Some(_inner),
            UpdateClusterConfigErrorKind::ResourceInUseException(_inner) => Some(_inner),
            UpdateClusterConfigErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            UpdateClusterConfigErrorKind::ServerException(_inner) => Some(_inner),
            UpdateClusterConfigErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateClusterVersionError {
    pub kind: UpdateClusterVersionErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateClusterVersionErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for UpdateClusterVersionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateClusterVersionErrorKind::ClientException(_inner) => _inner.fmt(f),
            UpdateClusterVersionErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            UpdateClusterVersionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            UpdateClusterVersionErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            UpdateClusterVersionErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            UpdateClusterVersionErrorKind::ServerException(_inner) => _inner.fmt(f),
            UpdateClusterVersionErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for UpdateClusterVersionError {
    fn code(&self) -> Option<&str> {
        UpdateClusterVersionError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl UpdateClusterVersionError {
    pub fn new(kind: UpdateClusterVersionErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: UpdateClusterVersionErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateClusterVersionErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterVersionErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterVersionErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterVersionErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterVersionErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterVersionErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateClusterVersionErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for UpdateClusterVersionError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateClusterVersionErrorKind::ClientException(_inner) => Some(_inner),
            UpdateClusterVersionErrorKind::InvalidParameterException(_inner) => Some(_inner),
            UpdateClusterVersionErrorKind::InvalidRequestException(_inner) => Some(_inner),
            UpdateClusterVersionErrorKind::ResourceInUseException(_inner) => Some(_inner),
            UpdateClusterVersionErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            UpdateClusterVersionErrorKind::ServerException(_inner) => Some(_inner),
            UpdateClusterVersionErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateNodegroupConfigError {
    pub kind: UpdateNodegroupConfigErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateNodegroupConfigErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for UpdateNodegroupConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateNodegroupConfigErrorKind::ClientException(_inner) => _inner.fmt(f),
            UpdateNodegroupConfigErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            UpdateNodegroupConfigErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            UpdateNodegroupConfigErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            UpdateNodegroupConfigErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            UpdateNodegroupConfigErrorKind::ServerException(_inner) => _inner.fmt(f),
            UpdateNodegroupConfigErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for UpdateNodegroupConfigError {
    fn code(&self) -> Option<&str> {
        UpdateNodegroupConfigError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl UpdateNodegroupConfigError {
    pub fn new(kind: UpdateNodegroupConfigErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: UpdateNodegroupConfigErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateNodegroupConfigErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupConfigErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupConfigErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupConfigErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupConfigErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupConfigErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupConfigErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for UpdateNodegroupConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateNodegroupConfigErrorKind::ClientException(_inner) => Some(_inner),
            UpdateNodegroupConfigErrorKind::InvalidParameterException(_inner) => Some(_inner),
            UpdateNodegroupConfigErrorKind::InvalidRequestException(_inner) => Some(_inner),
            UpdateNodegroupConfigErrorKind::ResourceInUseException(_inner) => Some(_inner),
            UpdateNodegroupConfigErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            UpdateNodegroupConfigErrorKind::ServerException(_inner) => Some(_inner),
            UpdateNodegroupConfigErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub struct UpdateNodegroupVersionError {
    pub kind: UpdateNodegroupVersionErrorKind,
    pub(crate) meta: smithy_types::Error,
}
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum UpdateNodegroupVersionErrorKind {
    ClientException(crate::error::ClientException),
    InvalidParameterException(crate::error::InvalidParameterException),
    InvalidRequestException(crate::error::InvalidRequestException),
    ResourceInUseException(crate::error::ResourceInUseException),
    ResourceNotFoundException(crate::error::ResourceNotFoundException),
    ServerException(crate::error::ServerException),
    /// An unexpected error, eg. invalid JSON returned by the service or an unknown error code
    Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for UpdateNodegroupVersionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &self.kind {
            UpdateNodegroupVersionErrorKind::ClientException(_inner) => _inner.fmt(f),
            UpdateNodegroupVersionErrorKind::InvalidParameterException(_inner) => _inner.fmt(f),
            UpdateNodegroupVersionErrorKind::InvalidRequestException(_inner) => _inner.fmt(f),
            UpdateNodegroupVersionErrorKind::ResourceInUseException(_inner) => _inner.fmt(f),
            UpdateNodegroupVersionErrorKind::ResourceNotFoundException(_inner) => _inner.fmt(f),
            UpdateNodegroupVersionErrorKind::ServerException(_inner) => _inner.fmt(f),
            UpdateNodegroupVersionErrorKind::Unhandled(_inner) => _inner.fmt(f),
        }
    }
}
impl smithy_types::retry::ProvideErrorKind for UpdateNodegroupVersionError {
    fn code(&self) -> Option<&str> {
        UpdateNodegroupVersionError::code(self)
    }
    fn retryable_error_kind(&self) -> Option<smithy_types::retry::ErrorKind> {
        None
    }
}
impl UpdateNodegroupVersionError {
    pub fn new(kind: UpdateNodegroupVersionErrorKind, meta: smithy_types::Error) -> Self {
        Self { kind, meta }
    }

    pub fn unhandled(err: impl Into<Box<dyn std::error::Error + Send + Sync + 'static>>) -> Self {
        Self {
            kind: UpdateNodegroupVersionErrorKind::Unhandled(err.into()),
            meta: Default::default(),
        }
    }

    pub fn generic(err: smithy_types::Error) -> Self {
        Self {
            meta: err.clone(),
            kind: UpdateNodegroupVersionErrorKind::Unhandled(err.into()),
        }
    }

    // Consider if this should actually be `Option<Cow<&str>>`. This would enable us to use display
    // as implemented by std::Error to generate a message in that case.
    pub fn message(&self) -> Option<&str> {
        self.meta.message()
    }

    pub fn meta(&self) -> &smithy_types::Error {
        &self.meta
    }

    pub fn request_id(&self) -> Option<&str> {
        self.meta.request_id()
    }

    pub fn code(&self) -> Option<&str> {
        self.meta.code()
    }
    pub fn is_client_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupVersionErrorKind::ClientException(_)
        )
    }
    pub fn is_invalid_parameter_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupVersionErrorKind::InvalidParameterException(_)
        )
    }
    pub fn is_invalid_request_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupVersionErrorKind::InvalidRequestException(_)
        )
    }
    pub fn is_resource_in_use_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupVersionErrorKind::ResourceInUseException(_)
        )
    }
    pub fn is_resource_not_found_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupVersionErrorKind::ResourceNotFoundException(_)
        )
    }
    pub fn is_server_exception(&self) -> bool {
        matches!(
            &self.kind,
            UpdateNodegroupVersionErrorKind::ServerException(_)
        )
    }
}
impl std::error::Error for UpdateNodegroupVersionError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match &self.kind {
            UpdateNodegroupVersionErrorKind::ClientException(_inner) => Some(_inner),
            UpdateNodegroupVersionErrorKind::InvalidParameterException(_inner) => Some(_inner),
            UpdateNodegroupVersionErrorKind::InvalidRequestException(_inner) => Some(_inner),
            UpdateNodegroupVersionErrorKind::ResourceInUseException(_inner) => Some(_inner),
            UpdateNodegroupVersionErrorKind::ResourceNotFoundException(_inner) => Some(_inner),
            UpdateNodegroupVersionErrorKind::ServerException(_inner) => Some(_inner),
            UpdateNodegroupVersionErrorKind::Unhandled(_inner) => Some(_inner.as_ref()),
        }
    }
}

/// <p>These errors are usually caused by a server-side issue.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ServerException {
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    pub addon_name: std::option::Option<std::string::String>,
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ServerException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ServerException");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("addon_name", &self.addon_name);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl ServerException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ServerException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ServerException")?;
        if let Some(inner_1) = &self.message {
            write!(f, ": {}", inner_1)?;
        }
        Ok(())
    }
}
impl std::error::Error for ServerException {}
/// See [`ServerException`](crate::error::ServerException)
pub mod server_exception {
    /// A builder for [`ServerException`](crate::error::ServerException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) addon_name: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        pub fn addon_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.addon_name = Some(input.into());
            self
        }
        pub fn set_addon_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.addon_name = input;
            self
        }
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`ServerException`](crate::error::ServerException)
        pub fn build(self) -> crate::error::ServerException {
            crate::error::ServerException {
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                addon_name: self.addon_name,
                message: self.message,
            }
        }
    }
}
impl ServerException {
    /// Creates a new builder-style object to manufacture [`ServerException`](crate::error::ServerException)
    pub fn builder() -> crate::error::server_exception::Builder {
        crate::error::server_exception::Builder::default()
    }
}

/// <p>The specified resource could not be found. You can view your available clusters with
/// <a>ListClusters</a>. You can view your available managed node groups with
/// <a>ListNodegroups</a>. Amazon EKS clusters and node groups are
/// Region-specific.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ResourceNotFoundException {
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    /// <p>The Fargate profile associated with the exception.</p>
    pub fargate_profile_name: std::option::Option<std::string::String>,
    pub addon_name: std::option::Option<std::string::String>,
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ResourceNotFoundException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ResourceNotFoundException");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("fargate_profile_name", &self.fargate_profile_name);
        formatter.field("addon_name", &self.addon_name);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl ResourceNotFoundException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ResourceNotFoundException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ResourceNotFoundException")?;
        if let Some(inner_2) = &self.message {
            write!(f, ": {}", inner_2)?;
        }
        Ok(())
    }
}
impl std::error::Error for ResourceNotFoundException {}
/// See [`ResourceNotFoundException`](crate::error::ResourceNotFoundException)
pub mod resource_not_found_exception {
    /// A builder for [`ResourceNotFoundException`](crate::error::ResourceNotFoundException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) fargate_profile_name: std::option::Option<std::string::String>,
        pub(crate) addon_name: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        /// <p>The Fargate profile associated with the exception.</p>
        pub fn fargate_profile_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.fargate_profile_name = Some(input.into());
            self
        }
        pub fn set_fargate_profile_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.fargate_profile_name = input;
            self
        }
        pub fn addon_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.addon_name = Some(input.into());
            self
        }
        pub fn set_addon_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.addon_name = input;
            self
        }
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`ResourceNotFoundException`](crate::error::ResourceNotFoundException)
        pub fn build(self) -> crate::error::ResourceNotFoundException {
            crate::error::ResourceNotFoundException {
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                fargate_profile_name: self.fargate_profile_name,
                addon_name: self.addon_name,
                message: self.message,
            }
        }
    }
}
impl ResourceNotFoundException {
    /// Creates a new builder-style object to manufacture [`ResourceNotFoundException`](crate::error::ResourceNotFoundException)
    pub fn builder() -> crate::error::resource_not_found_exception::Builder {
        crate::error::resource_not_found_exception::Builder::default()
    }
}

/// <p>The specified resource is in use.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ResourceInUseException {
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    pub addon_name: std::option::Option<std::string::String>,
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ResourceInUseException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ResourceInUseException");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("addon_name", &self.addon_name);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl ResourceInUseException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ResourceInUseException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ResourceInUseException")?;
        if let Some(inner_3) = &self.message {
            write!(f, ": {}", inner_3)?;
        }
        Ok(())
    }
}
impl std::error::Error for ResourceInUseException {}
/// See [`ResourceInUseException`](crate::error::ResourceInUseException)
pub mod resource_in_use_exception {
    /// A builder for [`ResourceInUseException`](crate::error::ResourceInUseException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) addon_name: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        pub fn addon_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.addon_name = Some(input.into());
            self
        }
        pub fn set_addon_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.addon_name = input;
            self
        }
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`ResourceInUseException`](crate::error::ResourceInUseException)
        pub fn build(self) -> crate::error::ResourceInUseException {
            crate::error::ResourceInUseException {
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                addon_name: self.addon_name,
                message: self.message,
            }
        }
    }
}
impl ResourceInUseException {
    /// Creates a new builder-style object to manufacture [`ResourceInUseException`](crate::error::ResourceInUseException)
    pub fn builder() -> crate::error::resource_in_use_exception::Builder {
        crate::error::resource_in_use_exception::Builder::default()
    }
}

/// <p>The request is invalid given the state of the cluster. Check the state of the cluster
/// and the associated operations.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct InvalidRequestException {
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    pub addon_name: std::option::Option<std::string::String>,
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for InvalidRequestException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("InvalidRequestException");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("addon_name", &self.addon_name);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl InvalidRequestException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for InvalidRequestException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "InvalidRequestException")?;
        if let Some(inner_4) = &self.message {
            write!(f, ": {}", inner_4)?;
        }
        Ok(())
    }
}
impl std::error::Error for InvalidRequestException {}
/// See [`InvalidRequestException`](crate::error::InvalidRequestException)
pub mod invalid_request_exception {
    /// A builder for [`InvalidRequestException`](crate::error::InvalidRequestException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) addon_name: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        pub fn addon_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.addon_name = Some(input.into());
            self
        }
        pub fn set_addon_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.addon_name = input;
            self
        }
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`InvalidRequestException`](crate::error::InvalidRequestException)
        pub fn build(self) -> crate::error::InvalidRequestException {
            crate::error::InvalidRequestException {
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                addon_name: self.addon_name,
                message: self.message,
            }
        }
    }
}
impl InvalidRequestException {
    /// Creates a new builder-style object to manufacture [`InvalidRequestException`](crate::error::InvalidRequestException)
    pub fn builder() -> crate::error::invalid_request_exception::Builder {
        crate::error::invalid_request_exception::Builder::default()
    }
}

/// <p>The specified parameter is invalid. Review the available parameters for the API
/// request.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct InvalidParameterException {
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    /// <p>The Fargate profile associated with the exception.</p>
    pub fargate_profile_name: std::option::Option<std::string::String>,
    pub addon_name: std::option::Option<std::string::String>,
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for InvalidParameterException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("InvalidParameterException");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("fargate_profile_name", &self.fargate_profile_name);
        formatter.field("addon_name", &self.addon_name);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl InvalidParameterException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for InvalidParameterException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "InvalidParameterException")?;
        if let Some(inner_5) = &self.message {
            write!(f, ": {}", inner_5)?;
        }
        Ok(())
    }
}
impl std::error::Error for InvalidParameterException {}
/// See [`InvalidParameterException`](crate::error::InvalidParameterException)
pub mod invalid_parameter_exception {
    /// A builder for [`InvalidParameterException`](crate::error::InvalidParameterException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) fargate_profile_name: std::option::Option<std::string::String>,
        pub(crate) addon_name: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        /// <p>The Fargate profile associated with the exception.</p>
        pub fn fargate_profile_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.fargate_profile_name = Some(input.into());
            self
        }
        pub fn set_fargate_profile_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.fargate_profile_name = input;
            self
        }
        pub fn addon_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.addon_name = Some(input.into());
            self
        }
        pub fn set_addon_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.addon_name = input;
            self
        }
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`InvalidParameterException`](crate::error::InvalidParameterException)
        pub fn build(self) -> crate::error::InvalidParameterException {
            crate::error::InvalidParameterException {
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                fargate_profile_name: self.fargate_profile_name,
                addon_name: self.addon_name,
                message: self.message,
            }
        }
    }
}
impl InvalidParameterException {
    /// Creates a new builder-style object to manufacture [`InvalidParameterException`](crate::error::InvalidParameterException)
    pub fn builder() -> crate::error::invalid_parameter_exception::Builder {
        crate::error::invalid_parameter_exception::Builder::default()
    }
}

/// <p>These errors are usually caused by a client action. Actions can include using an
/// action or resource on behalf of a user that doesn't have permissions to use the action
/// or resource or specifying an identifier that is not valid.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ClientException {
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    pub addon_name: std::option::Option<std::string::String>,
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ClientException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ClientException");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("addon_name", &self.addon_name);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl ClientException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ClientException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ClientException")?;
        if let Some(inner_6) = &self.message {
            write!(f, ": {}", inner_6)?;
        }
        Ok(())
    }
}
impl std::error::Error for ClientException {}
/// See [`ClientException`](crate::error::ClientException)
pub mod client_exception {
    /// A builder for [`ClientException`](crate::error::ClientException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) addon_name: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        pub fn addon_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.addon_name = Some(input.into());
            self
        }
        pub fn set_addon_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.addon_name = input;
            self
        }
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`ClientException`](crate::error::ClientException)
        pub fn build(self) -> crate::error::ClientException {
            crate::error::ClientException {
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                addon_name: self.addon_name,
                message: self.message,
            }
        }
    }
}
impl ClientException {
    /// Creates a new builder-style object to manufacture [`ClientException`](crate::error::ClientException)
    pub fn builder() -> crate::error::client_exception::Builder {
        crate::error::client_exception::Builder::default()
    }
}

/// <p>A service resource associated with the request could not be found. Clients should not
/// retry such requests.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct NotFoundException {
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for NotFoundException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("NotFoundException");
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl NotFoundException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for NotFoundException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "NotFoundException")?;
        if let Some(inner_7) = &self.message {
            write!(f, ": {}", inner_7)?;
        }
        Ok(())
    }
}
impl std::error::Error for NotFoundException {}
/// See [`NotFoundException`](crate::error::NotFoundException)
pub mod not_found_exception {
    /// A builder for [`NotFoundException`](crate::error::NotFoundException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`NotFoundException`](crate::error::NotFoundException)
        pub fn build(self) -> crate::error::NotFoundException {
            crate::error::NotFoundException {
                message: self.message,
            }
        }
    }
}
impl NotFoundException {
    /// Creates a new builder-style object to manufacture [`NotFoundException`](crate::error::NotFoundException)
    pub fn builder() -> crate::error::not_found_exception::Builder {
        crate::error::not_found_exception::Builder::default()
    }
}

/// <p>This exception is thrown if the request contains a semantic error. The precise meaning
/// will depend on the API, and will be documented in the error message.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BadRequestException {
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for BadRequestException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("BadRequestException");
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl BadRequestException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for BadRequestException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "BadRequestException")?;
        if let Some(inner_8) = &self.message {
            write!(f, ": {}", inner_8)?;
        }
        Ok(())
    }
}
impl std::error::Error for BadRequestException {}
/// See [`BadRequestException`](crate::error::BadRequestException)
pub mod bad_request_exception {
    /// A builder for [`BadRequestException`](crate::error::BadRequestException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`BadRequestException`](crate::error::BadRequestException)
        pub fn build(self) -> crate::error::BadRequestException {
            crate::error::BadRequestException {
                message: self.message,
            }
        }
    }
}
impl BadRequestException {
    /// Creates a new builder-style object to manufacture [`BadRequestException`](crate::error::BadRequestException)
    pub fn builder() -> crate::error::bad_request_exception::Builder {
        crate::error::bad_request_exception::Builder::default()
    }
}

/// <p>The service is unavailable. Back off and retry the operation.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ServiceUnavailableException {
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ServiceUnavailableException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ServiceUnavailableException");
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl ServiceUnavailableException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ServiceUnavailableException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ServiceUnavailableException")?;
        if let Some(inner_9) = &self.message {
            write!(f, ": {}", inner_9)?;
        }
        Ok(())
    }
}
impl std::error::Error for ServiceUnavailableException {}
/// See [`ServiceUnavailableException`](crate::error::ServiceUnavailableException)
pub mod service_unavailable_exception {
    /// A builder for [`ServiceUnavailableException`](crate::error::ServiceUnavailableException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`ServiceUnavailableException`](crate::error::ServiceUnavailableException)
        pub fn build(self) -> crate::error::ServiceUnavailableException {
            crate::error::ServiceUnavailableException {
                message: self.message,
            }
        }
    }
}
impl ServiceUnavailableException {
    /// Creates a new builder-style object to manufacture [`ServiceUnavailableException`](crate::error::ServiceUnavailableException)
    pub fn builder() -> crate::error::service_unavailable_exception::Builder {
        crate::error::service_unavailable_exception::Builder::default()
    }
}

/// <p>You have encountered a service limit on the specified resource.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ResourceLimitExceededException {
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    pub message: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ResourceLimitExceededException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ResourceLimitExceededException");
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("message", &self.message);
        formatter.finish()
    }
}
impl ResourceLimitExceededException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for ResourceLimitExceededException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ResourceLimitExceededException")?;
        if let Some(inner_10) = &self.message {
            write!(f, ": {}", inner_10)?;
        }
        Ok(())
    }
}
impl std::error::Error for ResourceLimitExceededException {}
/// See [`ResourceLimitExceededException`](crate::error::ResourceLimitExceededException)
pub mod resource_limit_exceeded_exception {
    /// A builder for [`ResourceLimitExceededException`](crate::error::ResourceLimitExceededException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) message: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Consumes the builder and constructs a [`ResourceLimitExceededException`](crate::error::ResourceLimitExceededException)
        pub fn build(self) -> crate::error::ResourceLimitExceededException {
            crate::error::ResourceLimitExceededException {
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                message: self.message,
            }
        }
    }
}
impl ResourceLimitExceededException {
    /// Creates a new builder-style object to manufacture [`ResourceLimitExceededException`](crate::error::ResourceLimitExceededException)
    pub fn builder() -> crate::error::resource_limit_exceeded_exception::Builder {
        crate::error::resource_limit_exceeded_exception::Builder::default()
    }
}

/// <p>At least one of your specified cluster subnets is in an Availability Zone that does
/// not support Amazon EKS. The exception output specifies the supported Availability Zones for
/// your account, from which you can choose subnets for your cluster.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UnsupportedAvailabilityZoneException {
    pub message: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS cluster associated with the exception.</p>
    pub cluster_name: std::option::Option<std::string::String>,
    /// <p>The Amazon EKS managed node group associated with the exception.</p>
    pub nodegroup_name: std::option::Option<std::string::String>,
    /// <p>The supported Availability Zones for your account. Choose subnets in these
    /// Availability Zones for your cluster.</p>
    pub valid_zones: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl std::fmt::Debug for UnsupportedAvailabilityZoneException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UnsupportedAvailabilityZoneException");
        formatter.field("message", &self.message);
        formatter.field("cluster_name", &self.cluster_name);
        formatter.field("nodegroup_name", &self.nodegroup_name);
        formatter.field("valid_zones", &self.valid_zones);
        formatter.finish()
    }
}
impl UnsupportedAvailabilityZoneException {
    pub fn message(&self) -> Option<&str> {
        self.message.as_deref()
    }
}
impl std::fmt::Display for UnsupportedAvailabilityZoneException {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "UnsupportedAvailabilityZoneException")?;
        if let Some(inner_11) = &self.message {
            write!(f, ": {}", inner_11)?;
        }
        Ok(())
    }
}
impl std::error::Error for UnsupportedAvailabilityZoneException {}
/// See [`UnsupportedAvailabilityZoneException`](crate::error::UnsupportedAvailabilityZoneException)
pub mod unsupported_availability_zone_exception {
    /// A builder for [`UnsupportedAvailabilityZoneException`](crate::error::UnsupportedAvailabilityZoneException)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) cluster_name: std::option::Option<std::string::String>,
        pub(crate) nodegroup_name: std::option::Option<std::string::String>,
        pub(crate) valid_zones: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// <p>The Amazon EKS cluster associated with the exception.</p>
        pub fn cluster_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.cluster_name = Some(input.into());
            self
        }
        pub fn set_cluster_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.cluster_name = input;
            self
        }
        /// <p>The Amazon EKS managed node group associated with the exception.</p>
        pub fn nodegroup_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.nodegroup_name = Some(input.into());
            self
        }
        pub fn set_nodegroup_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.nodegroup_name = input;
            self
        }
        pub fn valid_zones(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.valid_zones.unwrap_or_default();
            v.push(input.into());
            self.valid_zones = Some(v);
            self
        }
        pub fn set_valid_zones(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.valid_zones = input;
            self
        }
        /// Consumes the builder and constructs a [`UnsupportedAvailabilityZoneException`](crate::error::UnsupportedAvailabilityZoneException)
        pub fn build(self) -> crate::error::UnsupportedAvailabilityZoneException {
            crate::error::UnsupportedAvailabilityZoneException {
                message: self.message,
                cluster_name: self.cluster_name,
                nodegroup_name: self.nodegroup_name,
                valid_zones: self.valid_zones,
            }
        }
    }
}
impl UnsupportedAvailabilityZoneException {
    /// Creates a new builder-style object to manufacture [`UnsupportedAvailabilityZoneException`](crate::error::UnsupportedAvailabilityZoneException)
    pub fn builder() -> crate::error::unsupported_availability_zone_exception::Builder {
        crate::error::unsupported_availability_zone_exception::Builder::default()
    }
}
