// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// All possible error types for this service.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum Error {
    /// <p>An API error occurred. Wait a few minutes and try again.</p>
    ConcurrentModificationException(crate::types::error::ConcurrentModificationException),
    /// <p>The entitlement already exists.</p>
    EntitlementAlreadyExistsException(crate::types::error::EntitlementAlreadyExistsException),
    /// <p>The entitlement can't be found.</p>
    EntitlementNotFoundException(crate::types::error::EntitlementNotFoundException),
    /// <p>The image can't be updated because it's not compatible for updates.</p>
    IncompatibleImageException(crate::types::error::IncompatibleImageException),
    /// <p>The resource cannot be created because your AWS account is suspended. For assistance, contact AWS Support. </p>
    InvalidAccountStatusException(crate::types::error::InvalidAccountStatusException),
    /// <p>Indicates an incorrect combination of parameters, or a missing parameter.</p>
    InvalidParameterCombinationException(crate::types::error::InvalidParameterCombinationException),
    /// <p>The specified role is invalid.</p>
    InvalidRoleException(crate::types::error::InvalidRoleException),
    /// <p>The requested limit exceeds the permitted limit for an account.</p>
    LimitExceededException(crate::types::error::LimitExceededException),
    /// <p>The attempted operation is not permitted.</p>
    OperationNotPermittedException(crate::types::error::OperationNotPermittedException),
    /// <p>AppStream 2.0 can’t process the request right now because the Describe calls from your AWS account are being throttled by Amazon EC2. Try again later.</p>
    RequestLimitExceededException(crate::types::error::RequestLimitExceededException),
    /// <p>The specified resource already exists.</p>
    ResourceAlreadyExistsException(crate::types::error::ResourceAlreadyExistsException),
    /// <p>The specified resource is in use.</p>
    ResourceInUseException(crate::types::error::ResourceInUseException),
    /// <p>The specified resource exists and is not in use, but isn't available.</p>
    ResourceNotAvailableException(crate::types::error::ResourceNotAvailableException),
    /// <p>The specified resource was not found.</p>
    ResourceNotFoundException(crate::types::error::ResourceNotFoundException),
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
    Unhandled(aws_smithy_types::error::Unhandled),
}
impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::ConcurrentModificationException(inner) => inner.fmt(f),
            Error::EntitlementAlreadyExistsException(inner) => inner.fmt(f),
            Error::EntitlementNotFoundException(inner) => inner.fmt(f),
            Error::IncompatibleImageException(inner) => inner.fmt(f),
            Error::InvalidAccountStatusException(inner) => inner.fmt(f),
            Error::InvalidParameterCombinationException(inner) => inner.fmt(f),
            Error::InvalidRoleException(inner) => inner.fmt(f),
            Error::LimitExceededException(inner) => inner.fmt(f),
            Error::OperationNotPermittedException(inner) => inner.fmt(f),
            Error::RequestLimitExceededException(inner) => inner.fmt(f),
            Error::ResourceAlreadyExistsException(inner) => inner.fmt(f),
            Error::ResourceInUseException(inner) => inner.fmt(f),
            Error::ResourceNotAvailableException(inner) => inner.fmt(f),
            Error::ResourceNotFoundException(inner) => inner.fmt(f),
            Error::Unhandled(inner) => inner.fmt(f),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::associate_application_fleet::AssociateApplicationFleetError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::associate_application_fleet::AssociateApplicationFleetError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::associate_application_fleet::AssociateApplicationFleetError> for Error {
    fn from(
        err: crate::operation::associate_application_fleet::AssociateApplicationFleetError,
    ) -> Self {
        match err {
            crate::operation::associate_application_fleet::AssociateApplicationFleetError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::associate_application_fleet::AssociateApplicationFleetError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::associate_application_fleet::AssociateApplicationFleetError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::associate_application_fleet::AssociateApplicationFleetError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::associate_application_fleet::AssociateApplicationFleetError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::associate_application_fleet::AssociateApplicationFleetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError> for Error {
    fn from(err: crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError) -> Self {
        match err {
            crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError::EntitlementNotFoundException(inner) => Error::EntitlementNotFoundException(inner),
            crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::associate_application_to_entitlement::AssociateApplicationToEntitlementError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::associate_fleet::AssociateFleetError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::associate_fleet::AssociateFleetError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::associate_fleet::AssociateFleetError> for Error {
    fn from(err: crate::operation::associate_fleet::AssociateFleetError) -> Self {
        match err {
            crate::operation::associate_fleet::AssociateFleetError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::associate_fleet::AssociateFleetError::IncompatibleImageException(inner) => Error::IncompatibleImageException(inner),
            crate::operation::associate_fleet::AssociateFleetError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::associate_fleet::AssociateFleetError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::associate_fleet::AssociateFleetError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::associate_fleet::AssociateFleetError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::associate_fleet::AssociateFleetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::batch_associate_user_stack::BatchAssociateUserStackError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::batch_associate_user_stack::BatchAssociateUserStackError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::batch_associate_user_stack::BatchAssociateUserStackError> for Error {
    fn from(
        err: crate::operation::batch_associate_user_stack::BatchAssociateUserStackError,
    ) -> Self {
        match err {
            crate::operation::batch_associate_user_stack::BatchAssociateUserStackError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::batch_associate_user_stack::BatchAssociateUserStackError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::batch_associate_user_stack::BatchAssociateUserStackError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::batch_disassociate_user_stack::BatchDisassociateUserStackError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::batch_disassociate_user_stack::BatchDisassociateUserStackError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::batch_disassociate_user_stack::BatchDisassociateUserStackError>
    for Error
{
    fn from(
        err: crate::operation::batch_disassociate_user_stack::BatchDisassociateUserStackError,
    ) -> Self {
        match err {
            crate::operation::batch_disassociate_user_stack::BatchDisassociateUserStackError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::batch_disassociate_user_stack::BatchDisassociateUserStackError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::batch_disassociate_user_stack::BatchDisassociateUserStackError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::copy_image::CopyImageError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::copy_image::CopyImageError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::copy_image::CopyImageError> for Error {
    fn from(err: crate::operation::copy_image::CopyImageError) -> Self {
        match err {
            crate::operation::copy_image::CopyImageError::IncompatibleImageException(inner) => {
                Error::IncompatibleImageException(inner)
            }
            crate::operation::copy_image::CopyImageError::InvalidAccountStatusException(inner) => {
                Error::InvalidAccountStatusException(inner)
            }
            crate::operation::copy_image::CopyImageError::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::operation::copy_image::CopyImageError::ResourceAlreadyExistsException(inner) => {
                Error::ResourceAlreadyExistsException(inner)
            }
            crate::operation::copy_image::CopyImageError::ResourceNotAvailableException(inner) => {
                Error::ResourceNotAvailableException(inner)
            }
            crate::operation::copy_image::CopyImageError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::copy_image::CopyImageError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_app_block::CreateAppBlockError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_app_block::CreateAppBlockError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_app_block::CreateAppBlockError> for Error {
    fn from(err: crate::operation::create_app_block::CreateAppBlockError) -> Self {
        match err {
            crate::operation::create_app_block::CreateAppBlockError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::create_app_block::CreateAppBlockError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_app_block::CreateAppBlockError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_app_block::CreateAppBlockError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_app_block::CreateAppBlockError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_application::CreateApplicationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_application::CreateApplicationError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_application::CreateApplicationError> for Error {
    fn from(err: crate::operation::create_application::CreateApplicationError) -> Self {
        match err {
            crate::operation::create_application::CreateApplicationError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::create_application::CreateApplicationError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_application::CreateApplicationError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_application::CreateApplicationError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_application::CreateApplicationError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_application::CreateApplicationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_directory_config::CreateDirectoryConfigError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_directory_config::CreateDirectoryConfigError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_directory_config::CreateDirectoryConfigError> for Error {
    fn from(err: crate::operation::create_directory_config::CreateDirectoryConfigError) -> Self {
        match err {
            crate::operation::create_directory_config::CreateDirectoryConfigError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::create_directory_config::CreateDirectoryConfigError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::create_directory_config::CreateDirectoryConfigError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_directory_config::CreateDirectoryConfigError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_directory_config::CreateDirectoryConfigError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_directory_config::CreateDirectoryConfigError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_directory_config::CreateDirectoryConfigError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_entitlement::CreateEntitlementError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_entitlement::CreateEntitlementError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_entitlement::CreateEntitlementError> for Error {
    fn from(err: crate::operation::create_entitlement::CreateEntitlementError) -> Self {
        match err {
            crate::operation::create_entitlement::CreateEntitlementError::EntitlementAlreadyExistsException(inner) => Error::EntitlementAlreadyExistsException(inner),
            crate::operation::create_entitlement::CreateEntitlementError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_entitlement::CreateEntitlementError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_entitlement::CreateEntitlementError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_entitlement::CreateEntitlementError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::create_fleet::CreateFleetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::create_fleet::CreateFleetError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_fleet::CreateFleetError> for Error {
    fn from(err: crate::operation::create_fleet::CreateFleetError) -> Self {
        match err {
            crate::operation::create_fleet::CreateFleetError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::create_fleet::CreateFleetError::IncompatibleImageException(inner) => Error::IncompatibleImageException(inner),
            crate::operation::create_fleet::CreateFleetError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::create_fleet::CreateFleetError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::create_fleet::CreateFleetError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::create_fleet::CreateFleetError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_fleet::CreateFleetError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_fleet::CreateFleetError::RequestLimitExceededException(inner) => Error::RequestLimitExceededException(inner),
            crate::operation::create_fleet::CreateFleetError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_fleet::CreateFleetError::ResourceNotAvailableException(inner) => Error::ResourceNotAvailableException(inner),
            crate::operation::create_fleet::CreateFleetError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_fleet::CreateFleetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_image_builder::CreateImageBuilderError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_image_builder::CreateImageBuilderError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_image_builder::CreateImageBuilderError> for Error {
    fn from(err: crate::operation::create_image_builder::CreateImageBuilderError) -> Self {
        match err {
            crate::operation::create_image_builder::CreateImageBuilderError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::IncompatibleImageException(inner) => Error::IncompatibleImageException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::RequestLimitExceededException(inner) => Error::RequestLimitExceededException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::ResourceNotAvailableException(inner) => Error::ResourceNotAvailableException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_image_builder::CreateImageBuilderError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::create_image_builder_streaming_url::CreateImageBuilderStreamingURLError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::create_image_builder_streaming_url::CreateImageBuilderStreamingURLError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::create_image_builder_streaming_url::CreateImageBuilderStreamingURLError>
    for Error
{
    fn from(
        err: crate::operation::create_image_builder_streaming_url::CreateImageBuilderStreamingURLError,
    ) -> Self {
        match err {
            crate::operation::create_image_builder_streaming_url::CreateImageBuilderStreamingURLError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_image_builder_streaming_url::CreateImageBuilderStreamingURLError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_image_builder_streaming_url::CreateImageBuilderStreamingURLError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::create_stack::CreateStackError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::create_stack::CreateStackError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_stack::CreateStackError> for Error {
    fn from(err: crate::operation::create_stack::CreateStackError) -> Self {
        match err {
            crate::operation::create_stack::CreateStackError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::create_stack::CreateStackError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::create_stack::CreateStackError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::create_stack::CreateStackError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::create_stack::CreateStackError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_stack::CreateStackError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_stack::CreateStackError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_stack::CreateStackError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_streaming_url::CreateStreamingURLError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_streaming_url::CreateStreamingURLError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_streaming_url::CreateStreamingURLError> for Error {
    fn from(err: crate::operation::create_streaming_url::CreateStreamingURLError) -> Self {
        match err {
            crate::operation::create_streaming_url::CreateStreamingURLError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::create_streaming_url::CreateStreamingURLError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_streaming_url::CreateStreamingURLError::ResourceNotAvailableException(inner) => Error::ResourceNotAvailableException(inner),
            crate::operation::create_streaming_url::CreateStreamingURLError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_streaming_url::CreateStreamingURLError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_updated_image::CreateUpdatedImageError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_updated_image::CreateUpdatedImageError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_updated_image::CreateUpdatedImageError> for Error {
    fn from(err: crate::operation::create_updated_image::CreateUpdatedImageError) -> Self {
        match err {
            crate::operation::create_updated_image::CreateUpdatedImageError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::create_updated_image::CreateUpdatedImageError::IncompatibleImageException(inner) => Error::IncompatibleImageException(inner),
            crate::operation::create_updated_image::CreateUpdatedImageError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::create_updated_image::CreateUpdatedImageError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_updated_image::CreateUpdatedImageError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_updated_image::CreateUpdatedImageError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_updated_image::CreateUpdatedImageError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_updated_image::CreateUpdatedImageError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError>
    for Error
{
    fn from(
        err: crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError,
    ) -> Self {
        match err {
            crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_usage_report_subscription::CreateUsageReportSubscriptionError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::create_user::CreateUserError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::create_user::CreateUserError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_user::CreateUserError> for Error {
    fn from(err: crate::operation::create_user::CreateUserError) -> Self {
        match err {
            crate::operation::create_user::CreateUserError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::create_user::CreateUserError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::create_user::CreateUserError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::create_user::CreateUserError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_user::CreateUserError::ResourceAlreadyExistsException(inner) => Error::ResourceAlreadyExistsException(inner),
            crate::operation::create_user::CreateUserError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_app_block::DeleteAppBlockError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_app_block::DeleteAppBlockError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_app_block::DeleteAppBlockError> for Error {
    fn from(err: crate::operation::delete_app_block::DeleteAppBlockError) -> Self {
        match err {
            crate::operation::delete_app_block::DeleteAppBlockError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::delete_app_block::DeleteAppBlockError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
            crate::operation::delete_app_block::DeleteAppBlockError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_app_block::DeleteAppBlockError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_application::DeleteApplicationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_application::DeleteApplicationError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_application::DeleteApplicationError> for Error {
    fn from(err: crate::operation::delete_application::DeleteApplicationError) -> Self {
        match err {
            crate::operation::delete_application::DeleteApplicationError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::delete_application::DeleteApplicationError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::delete_application::DeleteApplicationError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
            crate::operation::delete_application::DeleteApplicationError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_application::DeleteApplicationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_directory_config::DeleteDirectoryConfigError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_directory_config::DeleteDirectoryConfigError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_directory_config::DeleteDirectoryConfigError> for Error {
    fn from(err: crate::operation::delete_directory_config::DeleteDirectoryConfigError) -> Self {
        match err {
            crate::operation::delete_directory_config::DeleteDirectoryConfigError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
            crate::operation::delete_directory_config::DeleteDirectoryConfigError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_directory_config::DeleteDirectoryConfigError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_entitlement::DeleteEntitlementError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_entitlement::DeleteEntitlementError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_entitlement::DeleteEntitlementError> for Error {
    fn from(err: crate::operation::delete_entitlement::DeleteEntitlementError) -> Self {
        match err {
            crate::operation::delete_entitlement::DeleteEntitlementError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::delete_entitlement::DeleteEntitlementError::EntitlementNotFoundException(inner) => Error::EntitlementNotFoundException(inner),
            crate::operation::delete_entitlement::DeleteEntitlementError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::delete_entitlement::DeleteEntitlementError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_entitlement::DeleteEntitlementError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::delete_fleet::DeleteFleetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::delete_fleet::DeleteFleetError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_fleet::DeleteFleetError> for Error {
    fn from(err: crate::operation::delete_fleet::DeleteFleetError) -> Self {
        match err {
            crate::operation::delete_fleet::DeleteFleetError::ConcurrentModificationException(
                inner,
            ) => Error::ConcurrentModificationException(inner),
            crate::operation::delete_fleet::DeleteFleetError::ResourceInUseException(inner) => {
                Error::ResourceInUseException(inner)
            }
            crate::operation::delete_fleet::DeleteFleetError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::delete_fleet::DeleteFleetError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::delete_image::DeleteImageError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::delete_image::DeleteImageError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_image::DeleteImageError> for Error {
    fn from(err: crate::operation::delete_image::DeleteImageError) -> Self {
        match err {
            crate::operation::delete_image::DeleteImageError::ConcurrentModificationException(
                inner,
            ) => Error::ConcurrentModificationException(inner),
            crate::operation::delete_image::DeleteImageError::OperationNotPermittedException(
                inner,
            ) => Error::OperationNotPermittedException(inner),
            crate::operation::delete_image::DeleteImageError::ResourceInUseException(inner) => {
                Error::ResourceInUseException(inner)
            }
            crate::operation::delete_image::DeleteImageError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::delete_image::DeleteImageError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_image_builder::DeleteImageBuilderError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_image_builder::DeleteImageBuilderError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_image_builder::DeleteImageBuilderError> for Error {
    fn from(err: crate::operation::delete_image_builder::DeleteImageBuilderError) -> Self {
        match err {
            crate::operation::delete_image_builder::DeleteImageBuilderError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::delete_image_builder::DeleteImageBuilderError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::delete_image_builder::DeleteImageBuilderError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_image_builder::DeleteImageBuilderError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_image_permissions::DeleteImagePermissionsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_image_permissions::DeleteImagePermissionsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_image_permissions::DeleteImagePermissionsError> for Error {
    fn from(err: crate::operation::delete_image_permissions::DeleteImagePermissionsError) -> Self {
        match err {
            crate::operation::delete_image_permissions::DeleteImagePermissionsError::ResourceNotAvailableException(inner) => Error::ResourceNotAvailableException(inner),
            crate::operation::delete_image_permissions::DeleteImagePermissionsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_image_permissions::DeleteImagePermissionsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::delete_stack::DeleteStackError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::delete_stack::DeleteStackError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_stack::DeleteStackError> for Error {
    fn from(err: crate::operation::delete_stack::DeleteStackError) -> Self {
        match err {
            crate::operation::delete_stack::DeleteStackError::ConcurrentModificationException(
                inner,
            ) => Error::ConcurrentModificationException(inner),
            crate::operation::delete_stack::DeleteStackError::OperationNotPermittedException(
                inner,
            ) => Error::OperationNotPermittedException(inner),
            crate::operation::delete_stack::DeleteStackError::ResourceInUseException(inner) => {
                Error::ResourceInUseException(inner)
            }
            crate::operation::delete_stack::DeleteStackError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::delete_stack::DeleteStackError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_usage_report_subscription::DeleteUsageReportSubscriptionError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_usage_report_subscription::DeleteUsageReportSubscriptionError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_usage_report_subscription::DeleteUsageReportSubscriptionError>
    for Error
{
    fn from(
        err: crate::operation::delete_usage_report_subscription::DeleteUsageReportSubscriptionError,
    ) -> Self {
        match err {
            crate::operation::delete_usage_report_subscription::DeleteUsageReportSubscriptionError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::delete_usage_report_subscription::DeleteUsageReportSubscriptionError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_usage_report_subscription::DeleteUsageReportSubscriptionError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::delete_user::DeleteUserError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::delete_user::DeleteUserError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_user::DeleteUserError> for Error {
    fn from(err: crate::operation::delete_user::DeleteUserError) -> Self {
        match err {
            crate::operation::delete_user::DeleteUserError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::delete_user::DeleteUserError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_app_blocks::DescribeAppBlocksError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_app_blocks::DescribeAppBlocksError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_app_blocks::DescribeAppBlocksError> for Error {
    fn from(err: crate::operation::describe_app_blocks::DescribeAppBlocksError) -> Self {
        match err {
            crate::operation::describe_app_blocks::DescribeAppBlocksError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::describe_app_blocks::DescribeAppBlocksError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_app_blocks::DescribeAppBlocksError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_application_fleet_associations::DescribeApplicationFleetAssociationsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_application_fleet_associations::DescribeApplicationFleetAssociationsError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::describe_application_fleet_associations::DescribeApplicationFleetAssociationsError> for Error {
    fn from(err: crate::operation::describe_application_fleet_associations::DescribeApplicationFleetAssociationsError) -> Self {
        match err {
            crate::operation::describe_application_fleet_associations::DescribeApplicationFleetAssociationsError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::describe_application_fleet_associations::DescribeApplicationFleetAssociationsError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::describe_application_fleet_associations::DescribeApplicationFleetAssociationsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_applications::DescribeApplicationsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_applications::DescribeApplicationsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_applications::DescribeApplicationsError> for Error {
    fn from(err: crate::operation::describe_applications::DescribeApplicationsError) -> Self {
        match err {
            crate::operation::describe_applications::DescribeApplicationsError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::describe_applications::DescribeApplicationsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_applications::DescribeApplicationsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_directory_configs::DescribeDirectoryConfigsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_directory_configs::DescribeDirectoryConfigsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_directory_configs::DescribeDirectoryConfigsError> for Error {
    fn from(
        err: crate::operation::describe_directory_configs::DescribeDirectoryConfigsError,
    ) -> Self {
        match err {
            crate::operation::describe_directory_configs::DescribeDirectoryConfigsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_directory_configs::DescribeDirectoryConfigsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_entitlements::DescribeEntitlementsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_entitlements::DescribeEntitlementsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_entitlements::DescribeEntitlementsError> for Error {
    fn from(err: crate::operation::describe_entitlements::DescribeEntitlementsError) -> Self {
        match err {
            crate::operation::describe_entitlements::DescribeEntitlementsError::EntitlementNotFoundException(inner) => Error::EntitlementNotFoundException(inner),
            crate::operation::describe_entitlements::DescribeEntitlementsError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::describe_entitlements::DescribeEntitlementsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_entitlements::DescribeEntitlementsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_fleets::DescribeFleetsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_fleets::DescribeFleetsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_fleets::DescribeFleetsError> for Error {
    fn from(err: crate::operation::describe_fleets::DescribeFleetsError) -> Self {
        match err {
            crate::operation::describe_fleets::DescribeFleetsError::ResourceNotFoundException(
                inner,
            ) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_fleets::DescribeFleetsError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_image_builders::DescribeImageBuildersError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_image_builders::DescribeImageBuildersError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_image_builders::DescribeImageBuildersError> for Error {
    fn from(err: crate::operation::describe_image_builders::DescribeImageBuildersError) -> Self {
        match err {
            crate::operation::describe_image_builders::DescribeImageBuildersError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_image_builders::DescribeImageBuildersError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_image_permissions::DescribeImagePermissionsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_image_permissions::DescribeImagePermissionsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_image_permissions::DescribeImagePermissionsError> for Error {
    fn from(
        err: crate::operation::describe_image_permissions::DescribeImagePermissionsError,
    ) -> Self {
        match err {
            crate::operation::describe_image_permissions::DescribeImagePermissionsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_image_permissions::DescribeImagePermissionsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_images::DescribeImagesError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_images::DescribeImagesError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_images::DescribeImagesError> for Error {
    fn from(err: crate::operation::describe_images::DescribeImagesError) -> Self {
        match err {
            crate::operation::describe_images::DescribeImagesError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::describe_images::DescribeImagesError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_images::DescribeImagesError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_sessions::DescribeSessionsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_sessions::DescribeSessionsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_sessions::DescribeSessionsError> for Error {
    fn from(err: crate::operation::describe_sessions::DescribeSessionsError) -> Self {
        match err {
            crate::operation::describe_sessions::DescribeSessionsError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::describe_sessions::DescribeSessionsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_stacks::DescribeStacksError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_stacks::DescribeStacksError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_stacks::DescribeStacksError> for Error {
    fn from(err: crate::operation::describe_stacks::DescribeStacksError) -> Self {
        match err {
            crate::operation::describe_stacks::DescribeStacksError::ResourceNotFoundException(
                inner,
            ) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_stacks::DescribeStacksError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_usage_report_subscriptions::DescribeUsageReportSubscriptionsError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_usage_report_subscriptions::DescribeUsageReportSubscriptionsError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::describe_usage_report_subscriptions::DescribeUsageReportSubscriptionsError> for Error {
    fn from(err: crate::operation::describe_usage_report_subscriptions::DescribeUsageReportSubscriptionsError) -> Self {
        match err {
            crate::operation::describe_usage_report_subscriptions::DescribeUsageReportSubscriptionsError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::describe_usage_report_subscriptions::DescribeUsageReportSubscriptionsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_usage_report_subscriptions::DescribeUsageReportSubscriptionsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<aws_smithy_http::result::SdkError<crate::operation::describe_users::DescribeUsersError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_users::DescribeUsersError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_users::DescribeUsersError> for Error {
    fn from(err: crate::operation::describe_users::DescribeUsersError) -> Self {
        match err {
            crate::operation::describe_users::DescribeUsersError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::describe_users::DescribeUsersError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::describe_users::DescribeUsersError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::describe_users::DescribeUsersError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_user_stack_associations::DescribeUserStackAssociationsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_user_stack_associations::DescribeUserStackAssociationsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_user_stack_associations::DescribeUserStackAssociationsError>
    for Error
{
    fn from(
        err: crate::operation::describe_user_stack_associations::DescribeUserStackAssociationsError,
    ) -> Self {
        match err {
            crate::operation::describe_user_stack_associations::DescribeUserStackAssociationsError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::describe_user_stack_associations::DescribeUserStackAssociationsError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::describe_user_stack_associations::DescribeUserStackAssociationsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::disable_user::DisableUserError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::disable_user::DisableUserError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::disable_user::DisableUserError> for Error {
    fn from(err: crate::operation::disable_user::DisableUserError) -> Self {
        match err {
            crate::operation::disable_user::DisableUserError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::disable_user::DisableUserError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError>
    for Error
{
    fn from(
        err: crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError,
    ) -> Self {
        match err {
            crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::disassociate_application_fleet::DisassociateApplicationFleetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError> for Error {
    fn from(err: crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError) -> Self {
        match err {
            crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError::EntitlementNotFoundException(inner) => Error::EntitlementNotFoundException(inner),
            crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::disassociate_application_from_entitlement::DisassociateApplicationFromEntitlementError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::disassociate_fleet::DisassociateFleetError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::disassociate_fleet::DisassociateFleetError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::disassociate_fleet::DisassociateFleetError> for Error {
    fn from(err: crate::operation::disassociate_fleet::DisassociateFleetError) -> Self {
        match err {
            crate::operation::disassociate_fleet::DisassociateFleetError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::disassociate_fleet::DisassociateFleetError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::disassociate_fleet::DisassociateFleetError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
            crate::operation::disassociate_fleet::DisassociateFleetError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::disassociate_fleet::DisassociateFleetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::enable_user::EnableUserError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::enable_user::EnableUserError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::enable_user::EnableUserError> for Error {
    fn from(err: crate::operation::enable_user::EnableUserError) -> Self {
        match err {
            crate::operation::enable_user::EnableUserError::InvalidAccountStatusException(
                inner,
            ) => Error::InvalidAccountStatusException(inner),
            crate::operation::enable_user::EnableUserError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::enable_user::EnableUserError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<aws_smithy_http::result::SdkError<crate::operation::expire_session::ExpireSessionError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::expire_session::ExpireSessionError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::expire_session::ExpireSessionError> for Error {
    fn from(err: crate::operation::expire_session::ExpireSessionError) -> Self {
        match err {
            crate::operation::expire_session::ExpireSessionError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::list_associated_fleets::ListAssociatedFleetsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::list_associated_fleets::ListAssociatedFleetsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::list_associated_fleets::ListAssociatedFleetsError> for Error {
    fn from(err: crate::operation::list_associated_fleets::ListAssociatedFleetsError) -> Self {
        match err {
            crate::operation::list_associated_fleets::ListAssociatedFleetsError::Unhandled(
                inner,
            ) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::list_associated_stacks::ListAssociatedStacksError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::list_associated_stacks::ListAssociatedStacksError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::list_associated_stacks::ListAssociatedStacksError> for Error {
    fn from(err: crate::operation::list_associated_stacks::ListAssociatedStacksError) -> Self {
        match err {
            crate::operation::list_associated_stacks::ListAssociatedStacksError::Unhandled(
                inner,
            ) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::list_entitled_applications::ListEntitledApplicationsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::list_entitled_applications::ListEntitledApplicationsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::list_entitled_applications::ListEntitledApplicationsError> for Error {
    fn from(
        err: crate::operation::list_entitled_applications::ListEntitledApplicationsError,
    ) -> Self {
        match err {
            crate::operation::list_entitled_applications::ListEntitledApplicationsError::EntitlementNotFoundException(inner) => Error::EntitlementNotFoundException(inner),
            crate::operation::list_entitled_applications::ListEntitledApplicationsError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::list_entitled_applications::ListEntitledApplicationsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::list_entitled_applications::ListEntitledApplicationsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::list_tags_for_resource::ListTagsForResourceError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::list_tags_for_resource::ListTagsForResourceError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::list_tags_for_resource::ListTagsForResourceError> for Error {
    fn from(err: crate::operation::list_tags_for_resource::ListTagsForResourceError) -> Self {
        match err {
            crate::operation::list_tags_for_resource::ListTagsForResourceError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::list_tags_for_resource::ListTagsForResourceError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::start_fleet::StartFleetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::start_fleet::StartFleetError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::start_fleet::StartFleetError> for Error {
    fn from(err: crate::operation::start_fleet::StartFleetError) -> Self {
        match err {
            crate::operation::start_fleet::StartFleetError::ConcurrentModificationException(
                inner,
            ) => Error::ConcurrentModificationException(inner),
            crate::operation::start_fleet::StartFleetError::InvalidAccountStatusException(
                inner,
            ) => Error::InvalidAccountStatusException(inner),
            crate::operation::start_fleet::StartFleetError::InvalidRoleException(inner) => {
                Error::InvalidRoleException(inner)
            }
            crate::operation::start_fleet::StartFleetError::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::operation::start_fleet::StartFleetError::OperationNotPermittedException(
                inner,
            ) => Error::OperationNotPermittedException(inner),
            crate::operation::start_fleet::StartFleetError::RequestLimitExceededException(
                inner,
            ) => Error::RequestLimitExceededException(inner),
            crate::operation::start_fleet::StartFleetError::ResourceNotAvailableException(
                inner,
            ) => Error::ResourceNotAvailableException(inner),
            crate::operation::start_fleet::StartFleetError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::start_fleet::StartFleetError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::start_image_builder::StartImageBuilderError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::start_image_builder::StartImageBuilderError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::start_image_builder::StartImageBuilderError> for Error {
    fn from(err: crate::operation::start_image_builder::StartImageBuilderError) -> Self {
        match err {
            crate::operation::start_image_builder::StartImageBuilderError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::start_image_builder::StartImageBuilderError::IncompatibleImageException(inner) => Error::IncompatibleImageException(inner),
            crate::operation::start_image_builder::StartImageBuilderError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::start_image_builder::StartImageBuilderError::ResourceNotAvailableException(inner) => Error::ResourceNotAvailableException(inner),
            crate::operation::start_image_builder::StartImageBuilderError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::start_image_builder::StartImageBuilderError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::stop_fleet::StopFleetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::stop_fleet::StopFleetError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::stop_fleet::StopFleetError> for Error {
    fn from(err: crate::operation::stop_fleet::StopFleetError) -> Self {
        match err {
            crate::operation::stop_fleet::StopFleetError::ConcurrentModificationException(
                inner,
            ) => Error::ConcurrentModificationException(inner),
            crate::operation::stop_fleet::StopFleetError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::stop_fleet::StopFleetError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::stop_image_builder::StopImageBuilderError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::stop_image_builder::StopImageBuilderError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::stop_image_builder::StopImageBuilderError> for Error {
    fn from(err: crate::operation::stop_image_builder::StopImageBuilderError) -> Self {
        match err {
            crate::operation::stop_image_builder::StopImageBuilderError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::stop_image_builder::StopImageBuilderError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::stop_image_builder::StopImageBuilderError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::stop_image_builder::StopImageBuilderError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::tag_resource::TagResourceError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::tag_resource::TagResourceError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::tag_resource::TagResourceError> for Error {
    fn from(err: crate::operation::tag_resource::TagResourceError) -> Self {
        match err {
            crate::operation::tag_resource::TagResourceError::InvalidAccountStatusException(
                inner,
            ) => Error::InvalidAccountStatusException(inner),
            crate::operation::tag_resource::TagResourceError::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::operation::tag_resource::TagResourceError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::tag_resource::TagResourceError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<aws_smithy_http::result::SdkError<crate::operation::untag_resource::UntagResourceError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::untag_resource::UntagResourceError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::untag_resource::UntagResourceError> for Error {
    fn from(err: crate::operation::untag_resource::UntagResourceError) -> Self {
        match err {
            crate::operation::untag_resource::UntagResourceError::ResourceNotFoundException(
                inner,
            ) => Error::ResourceNotFoundException(inner),
            crate::operation::untag_resource::UntagResourceError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::update_application::UpdateApplicationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::update_application::UpdateApplicationError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::update_application::UpdateApplicationError> for Error {
    fn from(err: crate::operation::update_application::UpdateApplicationError) -> Self {
        match err {
            crate::operation::update_application::UpdateApplicationError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::update_application::UpdateApplicationError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::update_application::UpdateApplicationError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::update_application::UpdateApplicationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::update_directory_config::UpdateDirectoryConfigError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::update_directory_config::UpdateDirectoryConfigError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::update_directory_config::UpdateDirectoryConfigError> for Error {
    fn from(err: crate::operation::update_directory_config::UpdateDirectoryConfigError) -> Self {
        match err {
            crate::operation::update_directory_config::UpdateDirectoryConfigError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::update_directory_config::UpdateDirectoryConfigError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::update_directory_config::UpdateDirectoryConfigError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::update_directory_config::UpdateDirectoryConfigError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
            crate::operation::update_directory_config::UpdateDirectoryConfigError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::update_directory_config::UpdateDirectoryConfigError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::update_entitlement::UpdateEntitlementError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::update_entitlement::UpdateEntitlementError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::update_entitlement::UpdateEntitlementError> for Error {
    fn from(err: crate::operation::update_entitlement::UpdateEntitlementError) -> Self {
        match err {
            crate::operation::update_entitlement::UpdateEntitlementError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::update_entitlement::UpdateEntitlementError::EntitlementNotFoundException(inner) => Error::EntitlementNotFoundException(inner),
            crate::operation::update_entitlement::UpdateEntitlementError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::update_entitlement::UpdateEntitlementError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::update_entitlement::UpdateEntitlementError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::update_fleet::UpdateFleetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::update_fleet::UpdateFleetError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::update_fleet::UpdateFleetError> for Error {
    fn from(err: crate::operation::update_fleet::UpdateFleetError) -> Self {
        match err {
            crate::operation::update_fleet::UpdateFleetError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::update_fleet::UpdateFleetError::IncompatibleImageException(inner) => Error::IncompatibleImageException(inner),
            crate::operation::update_fleet::UpdateFleetError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::update_fleet::UpdateFleetError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::update_fleet::UpdateFleetError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::update_fleet::UpdateFleetError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::update_fleet::UpdateFleetError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::update_fleet::UpdateFleetError::RequestLimitExceededException(inner) => Error::RequestLimitExceededException(inner),
            crate::operation::update_fleet::UpdateFleetError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
            crate::operation::update_fleet::UpdateFleetError::ResourceNotAvailableException(inner) => Error::ResourceNotAvailableException(inner),
            crate::operation::update_fleet::UpdateFleetError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::update_fleet::UpdateFleetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::update_image_permissions::UpdateImagePermissionsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::update_image_permissions::UpdateImagePermissionsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::update_image_permissions::UpdateImagePermissionsError> for Error {
    fn from(err: crate::operation::update_image_permissions::UpdateImagePermissionsError) -> Self {
        match err {
            crate::operation::update_image_permissions::UpdateImagePermissionsError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::update_image_permissions::UpdateImagePermissionsError::ResourceNotAvailableException(inner) => Error::ResourceNotAvailableException(inner),
            crate::operation::update_image_permissions::UpdateImagePermissionsError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::update_image_permissions::UpdateImagePermissionsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::update_stack::UpdateStackError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::update_stack::UpdateStackError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::update_stack::UpdateStackError> for Error {
    fn from(err: crate::operation::update_stack::UpdateStackError) -> Self {
        match err {
            crate::operation::update_stack::UpdateStackError::ConcurrentModificationException(inner) => Error::ConcurrentModificationException(inner),
            crate::operation::update_stack::UpdateStackError::IncompatibleImageException(inner) => Error::IncompatibleImageException(inner),
            crate::operation::update_stack::UpdateStackError::InvalidAccountStatusException(inner) => Error::InvalidAccountStatusException(inner),
            crate::operation::update_stack::UpdateStackError::InvalidParameterCombinationException(inner) => Error::InvalidParameterCombinationException(inner),
            crate::operation::update_stack::UpdateStackError::InvalidRoleException(inner) => Error::InvalidRoleException(inner),
            crate::operation::update_stack::UpdateStackError::LimitExceededException(inner) => Error::LimitExceededException(inner),
            crate::operation::update_stack::UpdateStackError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::update_stack::UpdateStackError::ResourceInUseException(inner) => Error::ResourceInUseException(inner),
            crate::operation::update_stack::UpdateStackError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::update_stack::UpdateStackError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl std::error::Error for Error {}
impl aws_http::request_id::RequestId for Error {
    fn request_id(&self) -> Option<&str> {
        match self {
            Self::ConcurrentModificationException(e) => e.request_id(),
            Self::EntitlementAlreadyExistsException(e) => e.request_id(),
            Self::EntitlementNotFoundException(e) => e.request_id(),
            Self::IncompatibleImageException(e) => e.request_id(),
            Self::InvalidAccountStatusException(e) => e.request_id(),
            Self::InvalidParameterCombinationException(e) => e.request_id(),
            Self::InvalidRoleException(e) => e.request_id(),
            Self::LimitExceededException(e) => e.request_id(),
            Self::OperationNotPermittedException(e) => e.request_id(),
            Self::RequestLimitExceededException(e) => e.request_id(),
            Self::ResourceAlreadyExistsException(e) => e.request_id(),
            Self::ResourceInUseException(e) => e.request_id(),
            Self::ResourceNotAvailableException(e) => e.request_id(),
            Self::ResourceNotFoundException(e) => e.request_id(),
            Self::Unhandled(e) => e.request_id(),
        }
    }
}