aws-sdk-apigateway 0.24.0

// 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>The submitted request is not valid, for example, the input is incomplete or incorrect. See the accompanying error message for details.</p>
    BadRequestException(crate::error::BadRequestException),
    /// <p>The request configuration has conflicts. For details, see the accompanying error message.</p>
    ConflictException(crate::error::ConflictException),
    /// <p>The request exceeded the rate limit. Retry after the specified time period.</p>
    LimitExceededException(crate::error::LimitExceededException),
    /// <p>The requested resource is not found. Make sure that the request URI is correct.</p>
    NotFoundException(crate::error::NotFoundException),
    /// <p>The requested service is not available. For details see the accompanying error message. Retry after the specified time period.</p>
    ServiceUnavailableException(crate::error::ServiceUnavailableException),
    /// <p>The request has reached its throttling limit. Retry after the specified time period.</p>
    TooManyRequestsException(crate::error::TooManyRequestsException),
    /// <p>The request is denied because the caller has insufficient permissions.</p>
    UnauthorizedException(crate::error::UnauthorizedException),
    ///
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
    ///
    /// When logging an error from the SDK, it is recommended that you either wrap the error in
    /// [`DisplayErrorContext`](crate::types::DisplayErrorContext), use another
    /// error reporter library that visits the error's cause/source chain, or call
    /// [`Error::source`](std::error::Error::source) for more details about the underlying cause.
    ///
    Unhandled(crate::error::Unhandled),
}
impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::BadRequestException(inner) => inner.fmt(f),
            Error::ConflictException(inner) => inner.fmt(f),
            Error::LimitExceededException(inner) => inner.fmt(f),
            Error::NotFoundException(inner) => inner.fmt(f),
            Error::ServiceUnavailableException(inner) => inner.fmt(f),
            Error::TooManyRequestsException(inner) => inner.fmt(f),
            Error::UnauthorizedException(inner) => inner.fmt(f),
            Error::Unhandled(inner) => inner.fmt(f),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateApiKeyError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::CreateApiKeyError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateApiKeyError> for Error {
    fn from(err: crate::error::CreateApiKeyError) -> Self {
        match err.kind {
            crate::error::CreateApiKeyErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateApiKeyErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateApiKeyErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateApiKeyErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateApiKeyErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateApiKeyErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateApiKeyErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateAuthorizerError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateAuthorizerError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateAuthorizerError> for Error {
    fn from(err: crate::error::CreateAuthorizerError) -> Self {
        match err.kind {
            crate::error::CreateAuthorizerErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateAuthorizerErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateAuthorizerErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateAuthorizerErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateAuthorizerErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateAuthorizerErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateAuthorizerErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateBasePathMappingError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateBasePathMappingError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateBasePathMappingError> for Error {
    fn from(err: crate::error::CreateBasePathMappingError) -> Self {
        match err.kind {
            crate::error::CreateBasePathMappingErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateBasePathMappingErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateBasePathMappingErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateBasePathMappingErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateBasePathMappingErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateBasePathMappingErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateBasePathMappingErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateDeploymentError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateDeploymentError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateDeploymentError> for Error {
    fn from(err: crate::error::CreateDeploymentError) -> Self {
        match err.kind {
            crate::error::CreateDeploymentErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateDeploymentErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateDeploymentErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateDeploymentErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateDeploymentErrorKind::ServiceUnavailableException(inner) => {
                Error::ServiceUnavailableException(inner)
            }
            crate::error::CreateDeploymentErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateDeploymentErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateDeploymentErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateDocumentationPartError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateDocumentationPartError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateDocumentationPartError> for Error {
    fn from(err: crate::error::CreateDocumentationPartError) -> Self {
        match err.kind {
            crate::error::CreateDocumentationPartErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateDocumentationPartErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateDocumentationPartErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateDocumentationPartErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateDocumentationPartErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateDocumentationPartErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateDocumentationPartErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateDocumentationVersionError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateDocumentationVersionError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateDocumentationVersionError> for Error {
    fn from(err: crate::error::CreateDocumentationVersionError) -> Self {
        match err.kind {
            crate::error::CreateDocumentationVersionErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateDocumentationVersionErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateDocumentationVersionErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateDocumentationVersionErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateDocumentationVersionErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateDocumentationVersionErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateDocumentationVersionErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateDomainNameError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateDomainNameError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateDomainNameError> for Error {
    fn from(err: crate::error::CreateDomainNameError) -> Self {
        match err.kind {
            crate::error::CreateDomainNameErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateDomainNameErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateDomainNameErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateDomainNameErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateDomainNameErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateDomainNameErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateModelError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::CreateModelError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateModelError> for Error {
    fn from(err: crate::error::CreateModelError) -> Self {
        match err.kind {
            crate::error::CreateModelErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateModelErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateModelErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateModelErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateModelErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateModelErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateModelErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateRequestValidatorError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateRequestValidatorError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateRequestValidatorError> for Error {
    fn from(err: crate::error::CreateRequestValidatorError) -> Self {
        match err.kind {
            crate::error::CreateRequestValidatorErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateRequestValidatorErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateRequestValidatorErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateRequestValidatorErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateRequestValidatorErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateRequestValidatorErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateRequestValidatorErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::CreateResourceError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateResourceError> for Error {
    fn from(err: crate::error::CreateResourceError) -> Self {
        match err.kind {
            crate::error::CreateResourceErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateResourceErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateResourceErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateResourceErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateResourceErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateResourceErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateResourceErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateRestApiError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::CreateRestApiError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateRestApiError> for Error {
    fn from(err: crate::error::CreateRestApiError) -> Self {
        match err.kind {
            crate::error::CreateRestApiErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateRestApiErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateRestApiErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateRestApiErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateRestApiErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateRestApiErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateStageError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::CreateStageError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateStageError> for Error {
    fn from(err: crate::error::CreateStageError) -> Self {
        match err.kind {
            crate::error::CreateStageErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateStageErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateStageErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateStageErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateStageErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateStageErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateStageErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateUsagePlanError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::CreateUsagePlanError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateUsagePlanError> for Error {
    fn from(err: crate::error::CreateUsagePlanError) -> Self {
        match err.kind {
            crate::error::CreateUsagePlanErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateUsagePlanErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateUsagePlanErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateUsagePlanErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateUsagePlanErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateUsagePlanErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateUsagePlanErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateUsagePlanKeyError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::CreateUsagePlanKeyError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateUsagePlanKeyError> for Error {
    fn from(err: crate::error::CreateUsagePlanKeyError) -> Self {
        match err.kind {
            crate::error::CreateUsagePlanKeyErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateUsagePlanKeyErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateUsagePlanKeyErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateUsagePlanKeyErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::CreateUsagePlanKeyErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateUsagePlanKeyErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateUsagePlanKeyErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::CreateVpcLinkError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::CreateVpcLinkError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::CreateVpcLinkError> for Error {
    fn from(err: crate::error::CreateVpcLinkError) -> Self {
        match err.kind {
            crate::error::CreateVpcLinkErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::CreateVpcLinkErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::CreateVpcLinkErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::CreateVpcLinkErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::CreateVpcLinkErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::CreateVpcLinkErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteApiKeyError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteApiKeyError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteApiKeyError> for Error {
    fn from(err: crate::error::DeleteApiKeyError) -> Self {
        match err.kind {
            crate::error::DeleteApiKeyErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteApiKeyErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteApiKeyErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteApiKeyErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteApiKeyErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteApiKeyErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteAuthorizerError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteAuthorizerError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteAuthorizerError> for Error {
    fn from(err: crate::error::DeleteAuthorizerError) -> Self {
        match err.kind {
            crate::error::DeleteAuthorizerErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteAuthorizerErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteAuthorizerErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteAuthorizerErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteAuthorizerErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteAuthorizerErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteBasePathMappingError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteBasePathMappingError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteBasePathMappingError> for Error {
    fn from(err: crate::error::DeleteBasePathMappingError) -> Self {
        match err.kind {
            crate::error::DeleteBasePathMappingErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteBasePathMappingErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteBasePathMappingErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteBasePathMappingErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteBasePathMappingErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteBasePathMappingErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteClientCertificateError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteClientCertificateError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteClientCertificateError> for Error {
    fn from(err: crate::error::DeleteClientCertificateError) -> Self {
        match err.kind {
            crate::error::DeleteClientCertificateErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteClientCertificateErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteClientCertificateErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteClientCertificateErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteClientCertificateErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteClientCertificateErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteDeploymentError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteDeploymentError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteDeploymentError> for Error {
    fn from(err: crate::error::DeleteDeploymentError) -> Self {
        match err.kind {
            crate::error::DeleteDeploymentErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteDeploymentErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteDeploymentErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::DeleteDeploymentErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteDeploymentErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteDeploymentErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteDeploymentErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteDocumentationPartError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteDocumentationPartError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteDocumentationPartError> for Error {
    fn from(err: crate::error::DeleteDocumentationPartError) -> Self {
        match err.kind {
            crate::error::DeleteDocumentationPartErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteDocumentationPartErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteDocumentationPartErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteDocumentationPartErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteDocumentationPartErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteDocumentationPartErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteDocumentationVersionError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteDocumentationVersionError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteDocumentationVersionError> for Error {
    fn from(err: crate::error::DeleteDocumentationVersionError) -> Self {
        match err.kind {
            crate::error::DeleteDocumentationVersionErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteDocumentationVersionErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteDocumentationVersionErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteDocumentationVersionErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteDocumentationVersionErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteDocumentationVersionErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteDomainNameError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteDomainNameError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteDomainNameError> for Error {
    fn from(err: crate::error::DeleteDomainNameError) -> Self {
        match err.kind {
            crate::error::DeleteDomainNameErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteDomainNameErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteDomainNameErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteDomainNameErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteDomainNameErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteDomainNameErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteGatewayResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteGatewayResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteGatewayResponseError> for Error {
    fn from(err: crate::error::DeleteGatewayResponseError) -> Self {
        match err.kind {
            crate::error::DeleteGatewayResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteGatewayResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteGatewayResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteGatewayResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteGatewayResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteGatewayResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteIntegrationError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteIntegrationError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteIntegrationError> for Error {
    fn from(err: crate::error::DeleteIntegrationError) -> Self {
        match err.kind {
            crate::error::DeleteIntegrationErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteIntegrationErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteIntegrationErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteIntegrationErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteIntegrationErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteIntegrationErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteIntegrationResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteIntegrationResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteIntegrationResponseError> for Error {
    fn from(err: crate::error::DeleteIntegrationResponseError) -> Self {
        match err.kind {
            crate::error::DeleteIntegrationResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteIntegrationResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteIntegrationResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteIntegrationResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteIntegrationResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteIntegrationResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteMethodError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteMethodError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteMethodError> for Error {
    fn from(err: crate::error::DeleteMethodError) -> Self {
        match err.kind {
            crate::error::DeleteMethodErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteMethodErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteMethodErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteMethodErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteMethodErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteMethodResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteMethodResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteMethodResponseError> for Error {
    fn from(err: crate::error::DeleteMethodResponseError) -> Self {
        match err.kind {
            crate::error::DeleteMethodResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteMethodResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteMethodResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteMethodResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteMethodResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteMethodResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteModelError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteModelError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteModelError> for Error {
    fn from(err: crate::error::DeleteModelError) -> Self {
        match err.kind {
            crate::error::DeleteModelErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteModelErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteModelErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteModelErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteModelErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteModelErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteRequestValidatorError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteRequestValidatorError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteRequestValidatorError> for Error {
    fn from(err: crate::error::DeleteRequestValidatorError) -> Self {
        match err.kind {
            crate::error::DeleteRequestValidatorErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteRequestValidatorErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteRequestValidatorErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteRequestValidatorErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteRequestValidatorErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteRequestValidatorErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteResourceError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteResourceError> for Error {
    fn from(err: crate::error::DeleteResourceError) -> Self {
        match err.kind {
            crate::error::DeleteResourceErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteResourceErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteResourceErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteResourceErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteResourceErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteResourceErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteRestApiError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteRestApiError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteRestApiError> for Error {
    fn from(err: crate::error::DeleteRestApiError) -> Self {
        match err.kind {
            crate::error::DeleteRestApiErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteRestApiErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteRestApiErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteRestApiErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteRestApiErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteRestApiErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteStageError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteStageError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteStageError> for Error {
    fn from(err: crate::error::DeleteStageError) -> Self {
        match err.kind {
            crate::error::DeleteStageErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteStageErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteStageErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::DeleteStageErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteStageErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteStageErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteStageErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteUsagePlanError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteUsagePlanError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteUsagePlanError> for Error {
    fn from(err: crate::error::DeleteUsagePlanError) -> Self {
        match err.kind {
            crate::error::DeleteUsagePlanErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteUsagePlanErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteUsagePlanErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteUsagePlanErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteUsagePlanErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteUsagePlanErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteUsagePlanKeyError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::DeleteUsagePlanKeyError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteUsagePlanKeyError> for Error {
    fn from(err: crate::error::DeleteUsagePlanKeyError) -> Self {
        match err.kind {
            crate::error::DeleteUsagePlanKeyErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteUsagePlanKeyErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteUsagePlanKeyErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteUsagePlanKeyErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteUsagePlanKeyErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteUsagePlanKeyErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::DeleteVpcLinkError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::DeleteVpcLinkError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::DeleteVpcLinkError> for Error {
    fn from(err: crate::error::DeleteVpcLinkError) -> Self {
        match err.kind {
            crate::error::DeleteVpcLinkErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::DeleteVpcLinkErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::DeleteVpcLinkErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::DeleteVpcLinkErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::DeleteVpcLinkErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::DeleteVpcLinkErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::FlushStageAuthorizersCacheError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::FlushStageAuthorizersCacheError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::FlushStageAuthorizersCacheError> for Error {
    fn from(err: crate::error::FlushStageAuthorizersCacheError) -> Self {
        match err.kind {
            crate::error::FlushStageAuthorizersCacheErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::FlushStageAuthorizersCacheErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::FlushStageAuthorizersCacheErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::FlushStageAuthorizersCacheErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::FlushStageAuthorizersCacheErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::FlushStageAuthorizersCacheErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::FlushStageAuthorizersCacheErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::FlushStageCacheError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::FlushStageCacheError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::FlushStageCacheError> for Error {
    fn from(err: crate::error::FlushStageCacheError) -> Self {
        match err.kind {
            crate::error::FlushStageCacheErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::FlushStageCacheErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::FlushStageCacheErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::FlushStageCacheErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::FlushStageCacheErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::FlushStageCacheErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::FlushStageCacheErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GenerateClientCertificateError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GenerateClientCertificateError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GenerateClientCertificateError> for Error {
    fn from(err: crate::error::GenerateClientCertificateError) -> Self {
        match err.kind {
            crate::error::GenerateClientCertificateErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GenerateClientCertificateErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::GenerateClientCertificateErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::GenerateClientCertificateErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GenerateClientCertificateErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GenerateClientCertificateErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetAccountError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetAccountError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetAccountError> for Error {
    fn from(err: crate::error::GetAccountError) -> Self {
        match err.kind {
            crate::error::GetAccountErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetAccountErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetAccountErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetAccountErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetAccountErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetApiKeyError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetApiKeyError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetApiKeyError> for Error {
    fn from(err: crate::error::GetApiKeyError) -> Self {
        match err.kind {
            crate::error::GetApiKeyErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetApiKeyErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetApiKeyErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetApiKeyErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetApiKeyErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetApiKeysError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetApiKeysError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetApiKeysError> for Error {
    fn from(err: crate::error::GetApiKeysError) -> Self {
        match err.kind {
            crate::error::GetApiKeysErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetApiKeysErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetApiKeysErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetApiKeysErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetApiKeysErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetAuthorizerError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetAuthorizerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetAuthorizerError> for Error {
    fn from(err: crate::error::GetAuthorizerError) -> Self {
        match err.kind {
            crate::error::GetAuthorizerErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetAuthorizerErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetAuthorizerErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetAuthorizerErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetAuthorizerErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetAuthorizersError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetAuthorizersError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetAuthorizersError> for Error {
    fn from(err: crate::error::GetAuthorizersError) -> Self {
        match err.kind {
            crate::error::GetAuthorizersErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetAuthorizersErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetAuthorizersErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetAuthorizersErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetAuthorizersErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetBasePathMappingError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetBasePathMappingError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetBasePathMappingError> for Error {
    fn from(err: crate::error::GetBasePathMappingError) -> Self {
        match err.kind {
            crate::error::GetBasePathMappingErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetBasePathMappingErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetBasePathMappingErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetBasePathMappingErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetBasePathMappingErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetBasePathMappingsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetBasePathMappingsError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetBasePathMappingsError> for Error {
    fn from(err: crate::error::GetBasePathMappingsError) -> Self {
        match err.kind {
            crate::error::GetBasePathMappingsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetBasePathMappingsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetBasePathMappingsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetBasePathMappingsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetBasePathMappingsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetClientCertificateError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetClientCertificateError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetClientCertificateError> for Error {
    fn from(err: crate::error::GetClientCertificateError) -> Self {
        match err.kind {
            crate::error::GetClientCertificateErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetClientCertificateErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetClientCertificateErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetClientCertificateErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetClientCertificateErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetClientCertificatesError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetClientCertificatesError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetClientCertificatesError> for Error {
    fn from(err: crate::error::GetClientCertificatesError) -> Self {
        match err.kind {
            crate::error::GetClientCertificatesErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetClientCertificatesErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetClientCertificatesErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetClientCertificatesErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetClientCertificatesErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDeploymentError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetDeploymentError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDeploymentError> for Error {
    fn from(err: crate::error::GetDeploymentError) -> Self {
        match err.kind {
            crate::error::GetDeploymentErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetDeploymentErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDeploymentErrorKind::ServiceUnavailableException(inner) => {
                Error::ServiceUnavailableException(inner)
            }
            crate::error::GetDeploymentErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDeploymentErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDeploymentErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDeploymentsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetDeploymentsError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDeploymentsError> for Error {
    fn from(err: crate::error::GetDeploymentsError) -> Self {
        match err.kind {
            crate::error::GetDeploymentsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetDeploymentsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDeploymentsErrorKind::ServiceUnavailableException(inner) => {
                Error::ServiceUnavailableException(inner)
            }
            crate::error::GetDeploymentsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDeploymentsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDeploymentsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDocumentationPartError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetDocumentationPartError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDocumentationPartError> for Error {
    fn from(err: crate::error::GetDocumentationPartError) -> Self {
        match err.kind {
            crate::error::GetDocumentationPartErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetDocumentationPartErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDocumentationPartErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDocumentationPartErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDocumentationPartErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDocumentationPartsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetDocumentationPartsError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDocumentationPartsError> for Error {
    fn from(err: crate::error::GetDocumentationPartsError) -> Self {
        match err.kind {
            crate::error::GetDocumentationPartsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetDocumentationPartsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDocumentationPartsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDocumentationPartsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDocumentationPartsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDocumentationVersionError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetDocumentationVersionError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDocumentationVersionError> for Error {
    fn from(err: crate::error::GetDocumentationVersionError) -> Self {
        match err.kind {
            crate::error::GetDocumentationVersionErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDocumentationVersionErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDocumentationVersionErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDocumentationVersionErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDocumentationVersionsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetDocumentationVersionsError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDocumentationVersionsError> for Error {
    fn from(err: crate::error::GetDocumentationVersionsError) -> Self {
        match err.kind {
            crate::error::GetDocumentationVersionsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetDocumentationVersionsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDocumentationVersionsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDocumentationVersionsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDocumentationVersionsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDomainNameError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetDomainNameError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDomainNameError> for Error {
    fn from(err: crate::error::GetDomainNameError) -> Self {
        match err.kind {
            crate::error::GetDomainNameErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetDomainNameErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDomainNameErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDomainNameErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDomainNameErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetDomainNamesError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetDomainNamesError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetDomainNamesError> for Error {
    fn from(err: crate::error::GetDomainNamesError) -> Self {
        match err.kind {
            crate::error::GetDomainNamesErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetDomainNamesErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetDomainNamesErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetDomainNamesErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetDomainNamesErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetExportError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetExportError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetExportError> for Error {
    fn from(err: crate::error::GetExportError) -> Self {
        match err.kind {
            crate::error::GetExportErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetExportErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::GetExportErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::GetExportErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetExportErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetExportErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetExportErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetGatewayResponseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetGatewayResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetGatewayResponseError> for Error {
    fn from(err: crate::error::GetGatewayResponseError) -> Self {
        match err.kind {
            crate::error::GetGatewayResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetGatewayResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetGatewayResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetGatewayResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetGatewayResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetGatewayResponsesError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetGatewayResponsesError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetGatewayResponsesError> for Error {
    fn from(err: crate::error::GetGatewayResponsesError) -> Self {
        match err.kind {
            crate::error::GetGatewayResponsesErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetGatewayResponsesErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetGatewayResponsesErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetGatewayResponsesErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetGatewayResponsesErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetIntegrationError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetIntegrationError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetIntegrationError> for Error {
    fn from(err: crate::error::GetIntegrationError) -> Self {
        match err.kind {
            crate::error::GetIntegrationErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetIntegrationErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetIntegrationErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetIntegrationErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetIntegrationErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetIntegrationResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetIntegrationResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetIntegrationResponseError> for Error {
    fn from(err: crate::error::GetIntegrationResponseError) -> Self {
        match err.kind {
            crate::error::GetIntegrationResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetIntegrationResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetIntegrationResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetIntegrationResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetIntegrationResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetMethodError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetMethodError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetMethodError> for Error {
    fn from(err: crate::error::GetMethodError) -> Self {
        match err.kind {
            crate::error::GetMethodErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetMethodErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetMethodErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetMethodErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetMethodResponseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetMethodResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetMethodResponseError> for Error {
    fn from(err: crate::error::GetMethodResponseError) -> Self {
        match err.kind {
            crate::error::GetMethodResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetMethodResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetMethodResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetMethodResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetModelError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetModelError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetModelError> for Error {
    fn from(err: crate::error::GetModelError) -> Self {
        match err.kind {
            crate::error::GetModelErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetModelErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetModelErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetModelErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetModelErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetModelsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetModelsError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetModelsError> for Error {
    fn from(err: crate::error::GetModelsError) -> Self {
        match err.kind {
            crate::error::GetModelsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetModelsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetModelsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetModelsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetModelsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetModelTemplateError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetModelTemplateError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetModelTemplateError> for Error {
    fn from(err: crate::error::GetModelTemplateError) -> Self {
        match err.kind {
            crate::error::GetModelTemplateErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetModelTemplateErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetModelTemplateErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetModelTemplateErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetModelTemplateErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetRequestValidatorError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetRequestValidatorError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetRequestValidatorError> for Error {
    fn from(err: crate::error::GetRequestValidatorError) -> Self {
        match err.kind {
            crate::error::GetRequestValidatorErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetRequestValidatorErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetRequestValidatorErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetRequestValidatorErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetRequestValidatorErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetRequestValidatorsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetRequestValidatorsError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetRequestValidatorsError> for Error {
    fn from(err: crate::error::GetRequestValidatorsError) -> Self {
        match err.kind {
            crate::error::GetRequestValidatorsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetRequestValidatorsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetRequestValidatorsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetRequestValidatorsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetRequestValidatorsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetResourceError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetResourceError> for Error {
    fn from(err: crate::error::GetResourceError) -> Self {
        match err.kind {
            crate::error::GetResourceErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetResourceErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetResourceErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetResourceErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetResourcesError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetResourcesError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetResourcesError> for Error {
    fn from(err: crate::error::GetResourcesError) -> Self {
        match err.kind {
            crate::error::GetResourcesErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetResourcesErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetResourcesErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetResourcesErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetResourcesErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetRestApiError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetRestApiError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetRestApiError> for Error {
    fn from(err: crate::error::GetRestApiError) -> Self {
        match err.kind {
            crate::error::GetRestApiErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetRestApiErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetRestApiErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetRestApiErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetRestApiErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetRestApisError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetRestApisError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetRestApisError> for Error {
    fn from(err: crate::error::GetRestApisError) -> Self {
        match err.kind {
            crate::error::GetRestApisErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetRestApisErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetRestApisErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetRestApisErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetRestApisErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetSdkError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetSdkError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetSdkError> for Error {
    fn from(err: crate::error::GetSdkError) -> Self {
        match err.kind {
            crate::error::GetSdkErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetSdkErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::GetSdkErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::GetSdkErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetSdkErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetSdkErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetSdkErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetSdkTypeError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetSdkTypeError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetSdkTypeError> for Error {
    fn from(err: crate::error::GetSdkTypeError) -> Self {
        match err.kind {
            crate::error::GetSdkTypeErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetSdkTypeErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetSdkTypeErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetSdkTypeErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetSdkTypeErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetSdkTypesError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetSdkTypesError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetSdkTypesError> for Error {
    fn from(err: crate::error::GetSdkTypesError) -> Self {
        match err.kind {
            crate::error::GetSdkTypesErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetSdkTypesErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetSdkTypesErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetSdkTypesErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetSdkTypesErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetStageError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetStageError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetStageError> for Error {
    fn from(err: crate::error::GetStageError) -> Self {
        match err.kind {
            crate::error::GetStageErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetStageErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::GetStageErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::GetStageErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetStageErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetStageErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetStageErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetStagesError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetStagesError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetStagesError> for Error {
    fn from(err: crate::error::GetStagesError) -> Self {
        match err.kind {
            crate::error::GetStagesErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetStagesErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::GetStagesErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::GetStagesErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetStagesErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetStagesErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetStagesErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetTagsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetTagsError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetTagsError> for Error {
    fn from(err: crate::error::GetTagsError) -> Self {
        match err.kind {
            crate::error::GetTagsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetTagsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetTagsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetTagsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetTagsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetUsageError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetUsageError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetUsageError> for Error {
    fn from(err: crate::error::GetUsageError) -> Self {
        match err.kind {
            crate::error::GetUsageErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetUsageErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetUsageErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetUsageErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetUsageErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetUsagePlanError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetUsagePlanError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetUsagePlanError> for Error {
    fn from(err: crate::error::GetUsagePlanError) -> Self {
        match err.kind {
            crate::error::GetUsagePlanErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetUsagePlanErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetUsagePlanErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetUsagePlanErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetUsagePlanErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetUsagePlanKeyError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetUsagePlanKeyError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetUsagePlanKeyError> for Error {
    fn from(err: crate::error::GetUsagePlanKeyError) -> Self {
        match err.kind {
            crate::error::GetUsagePlanKeyErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetUsagePlanKeyErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetUsagePlanKeyErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetUsagePlanKeyErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetUsagePlanKeyErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetUsagePlanKeysError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::GetUsagePlanKeysError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetUsagePlanKeysError> for Error {
    fn from(err: crate::error::GetUsagePlanKeysError) -> Self {
        match err.kind {
            crate::error::GetUsagePlanKeysErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetUsagePlanKeysErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetUsagePlanKeysErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetUsagePlanKeysErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetUsagePlanKeysErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetUsagePlansError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetUsagePlansError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetUsagePlansError> for Error {
    fn from(err: crate::error::GetUsagePlansError) -> Self {
        match err.kind {
            crate::error::GetUsagePlansErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetUsagePlansErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetUsagePlansErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetUsagePlansErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetUsagePlansErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetVpcLinkError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetVpcLinkError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetVpcLinkError> for Error {
    fn from(err: crate::error::GetVpcLinkError) -> Self {
        match err.kind {
            crate::error::GetVpcLinkErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetVpcLinkErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetVpcLinkErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetVpcLinkErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetVpcLinkErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::GetVpcLinksError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::GetVpcLinksError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::GetVpcLinksError> for Error {
    fn from(err: crate::error::GetVpcLinksError) -> Self {
        match err.kind {
            crate::error::GetVpcLinksErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::GetVpcLinksErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::GetVpcLinksErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::GetVpcLinksErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::GetVpcLinksErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::ImportApiKeysError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::ImportApiKeysError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::ImportApiKeysError> for Error {
    fn from(err: crate::error::ImportApiKeysError) -> Self {
        match err.kind {
            crate::error::ImportApiKeysErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::ImportApiKeysErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::ImportApiKeysErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::ImportApiKeysErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::ImportApiKeysErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::ImportApiKeysErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::ImportApiKeysErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::ImportDocumentationPartsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::ImportDocumentationPartsError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::ImportDocumentationPartsError> for Error {
    fn from(err: crate::error::ImportDocumentationPartsError) -> Self {
        match err.kind {
            crate::error::ImportDocumentationPartsErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::ImportDocumentationPartsErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::ImportDocumentationPartsErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::ImportDocumentationPartsErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::ImportDocumentationPartsErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::ImportDocumentationPartsErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::ImportDocumentationPartsErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::ImportRestApiError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::ImportRestApiError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::ImportRestApiError> for Error {
    fn from(err: crate::error::ImportRestApiError) -> Self {
        match err.kind {
            crate::error::ImportRestApiErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::ImportRestApiErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::ImportRestApiErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::ImportRestApiErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::ImportRestApiErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::ImportRestApiErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::ImportRestApiErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::PutGatewayResponseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::PutGatewayResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::PutGatewayResponseError> for Error {
    fn from(err: crate::error::PutGatewayResponseError) -> Self {
        match err.kind {
            crate::error::PutGatewayResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::PutGatewayResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::PutGatewayResponseErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::PutGatewayResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::PutGatewayResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::PutGatewayResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::PutGatewayResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::PutIntegrationError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::PutIntegrationError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::PutIntegrationError> for Error {
    fn from(err: crate::error::PutIntegrationError) -> Self {
        match err.kind {
            crate::error::PutIntegrationErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::PutIntegrationErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::PutIntegrationErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::PutIntegrationErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::PutIntegrationErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::PutIntegrationErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::PutIntegrationErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::PutIntegrationResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::PutIntegrationResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::PutIntegrationResponseError> for Error {
    fn from(err: crate::error::PutIntegrationResponseError) -> Self {
        match err.kind {
            crate::error::PutIntegrationResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::PutIntegrationResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::PutIntegrationResponseErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::PutIntegrationResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::PutIntegrationResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::PutIntegrationResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::PutIntegrationResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::PutMethodError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::PutMethodError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::PutMethodError> for Error {
    fn from(err: crate::error::PutMethodError) -> Self {
        match err.kind {
            crate::error::PutMethodErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::PutMethodErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::PutMethodErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::PutMethodErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::PutMethodErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::PutMethodErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::PutMethodErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::PutMethodResponseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::PutMethodResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::PutMethodResponseError> for Error {
    fn from(err: crate::error::PutMethodResponseError) -> Self {
        match err.kind {
            crate::error::PutMethodResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::PutMethodResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::PutMethodResponseErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::PutMethodResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::PutMethodResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::PutMethodResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::PutMethodResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::PutRestApiError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::PutRestApiError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::PutRestApiError> for Error {
    fn from(err: crate::error::PutRestApiError) -> Self {
        match err.kind {
            crate::error::PutRestApiErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::PutRestApiErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::PutRestApiErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::PutRestApiErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::PutRestApiErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::PutRestApiErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::PutRestApiErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::TagResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::TagResourceError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::TagResourceError> for Error {
    fn from(err: crate::error::TagResourceError) -> Self {
        match err.kind {
            crate::error::TagResourceErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::TagResourceErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::TagResourceErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::TagResourceErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::TagResourceErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::TagResourceErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::TagResourceErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::TestInvokeAuthorizerError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::TestInvokeAuthorizerError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::TestInvokeAuthorizerError> for Error {
    fn from(err: crate::error::TestInvokeAuthorizerError) -> Self {
        match err.kind {
            crate::error::TestInvokeAuthorizerErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::TestInvokeAuthorizerErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::TestInvokeAuthorizerErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::TestInvokeAuthorizerErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::TestInvokeAuthorizerErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::TestInvokeMethodError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::TestInvokeMethodError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::TestInvokeMethodError> for Error {
    fn from(err: crate::error::TestInvokeMethodError) -> Self {
        match err.kind {
            crate::error::TestInvokeMethodErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::TestInvokeMethodErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::TestInvokeMethodErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::TestInvokeMethodErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::TestInvokeMethodErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UntagResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UntagResourceError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UntagResourceError> for Error {
    fn from(err: crate::error::UntagResourceError) -> Self {
        match err.kind {
            crate::error::UntagResourceErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UntagResourceErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UntagResourceErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UntagResourceErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UntagResourceErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UntagResourceErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UntagResourceErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateAccountError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateAccountError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateAccountError> for Error {
    fn from(err: crate::error::UpdateAccountError) -> Self {
        match err.kind {
            crate::error::UpdateAccountErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateAccountErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateAccountErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateAccountErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateAccountErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateAccountErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateAccountErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateApiKeyError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateApiKeyError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateApiKeyError> for Error {
    fn from(err: crate::error::UpdateApiKeyError) -> Self {
        match err.kind {
            crate::error::UpdateApiKeyErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateApiKeyErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateApiKeyErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateApiKeyErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateApiKeyErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateApiKeyErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateApiKeyErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateAuthorizerError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateAuthorizerError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateAuthorizerError> for Error {
    fn from(err: crate::error::UpdateAuthorizerError) -> Self {
        match err.kind {
            crate::error::UpdateAuthorizerErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateAuthorizerErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateAuthorizerErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateAuthorizerErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateAuthorizerErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateAuthorizerErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateAuthorizerErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateBasePathMappingError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateBasePathMappingError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateBasePathMappingError> for Error {
    fn from(err: crate::error::UpdateBasePathMappingError) -> Self {
        match err.kind {
            crate::error::UpdateBasePathMappingErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateBasePathMappingErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateBasePathMappingErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateBasePathMappingErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateBasePathMappingErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateBasePathMappingErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateBasePathMappingErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateClientCertificateError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateClientCertificateError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateClientCertificateError> for Error {
    fn from(err: crate::error::UpdateClientCertificateError) -> Self {
        match err.kind {
            crate::error::UpdateClientCertificateErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateClientCertificateErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateClientCertificateErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateClientCertificateErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateClientCertificateErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateClientCertificateErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateClientCertificateErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateDeploymentError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateDeploymentError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateDeploymentError> for Error {
    fn from(err: crate::error::UpdateDeploymentError) -> Self {
        match err.kind {
            crate::error::UpdateDeploymentErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateDeploymentErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateDeploymentErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateDeploymentErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateDeploymentErrorKind::ServiceUnavailableException(inner) => {
                Error::ServiceUnavailableException(inner)
            }
            crate::error::UpdateDeploymentErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateDeploymentErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateDeploymentErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateDocumentationPartError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateDocumentationPartError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateDocumentationPartError> for Error {
    fn from(err: crate::error::UpdateDocumentationPartError) -> Self {
        match err.kind {
            crate::error::UpdateDocumentationPartErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateDocumentationPartErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateDocumentationPartErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateDocumentationPartErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateDocumentationPartErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateDocumentationPartErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateDocumentationPartErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateDocumentationVersionError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateDocumentationVersionError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateDocumentationVersionError> for Error {
    fn from(err: crate::error::UpdateDocumentationVersionError) -> Self {
        match err.kind {
            crate::error::UpdateDocumentationVersionErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateDocumentationVersionErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateDocumentationVersionErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateDocumentationVersionErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateDocumentationVersionErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateDocumentationVersionErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateDocumentationVersionErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateDomainNameError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateDomainNameError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateDomainNameError> for Error {
    fn from(err: crate::error::UpdateDomainNameError) -> Self {
        match err.kind {
            crate::error::UpdateDomainNameErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateDomainNameErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateDomainNameErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateDomainNameErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateDomainNameErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateDomainNameErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateDomainNameErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateGatewayResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateGatewayResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateGatewayResponseError> for Error {
    fn from(err: crate::error::UpdateGatewayResponseError) -> Self {
        match err.kind {
            crate::error::UpdateGatewayResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateGatewayResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateGatewayResponseErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateGatewayResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateGatewayResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateGatewayResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateGatewayResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateIntegrationError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateIntegrationError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateIntegrationError> for Error {
    fn from(err: crate::error::UpdateIntegrationError) -> Self {
        match err.kind {
            crate::error::UpdateIntegrationErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateIntegrationErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateIntegrationErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateIntegrationErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateIntegrationErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateIntegrationErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateIntegrationErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateIntegrationResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateIntegrationResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateIntegrationResponseError> for Error {
    fn from(err: crate::error::UpdateIntegrationResponseError) -> Self {
        match err.kind {
            crate::error::UpdateIntegrationResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateIntegrationResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateIntegrationResponseErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateIntegrationResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateIntegrationResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateIntegrationResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateIntegrationResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateMethodError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateMethodError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateMethodError> for Error {
    fn from(err: crate::error::UpdateMethodError) -> Self {
        match err.kind {
            crate::error::UpdateMethodErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateMethodErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateMethodErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateMethodErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateMethodErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateMethodErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateMethodResponseError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateMethodResponseError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateMethodResponseError> for Error {
    fn from(err: crate::error::UpdateMethodResponseError) -> Self {
        match err.kind {
            crate::error::UpdateMethodResponseErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateMethodResponseErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateMethodResponseErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateMethodResponseErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateMethodResponseErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateMethodResponseErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateMethodResponseErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateModelError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateModelError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateModelError> for Error {
    fn from(err: crate::error::UpdateModelError) -> Self {
        match err.kind {
            crate::error::UpdateModelErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateModelErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateModelErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateModelErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateModelErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateModelErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateModelErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateRequestValidatorError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::error::UpdateRequestValidatorError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateRequestValidatorError> for Error {
    fn from(err: crate::error::UpdateRequestValidatorError) -> Self {
        match err.kind {
            crate::error::UpdateRequestValidatorErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateRequestValidatorErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateRequestValidatorErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateRequestValidatorErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateRequestValidatorErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateRequestValidatorErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateRequestValidatorErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateResourceError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateResourceError> for Error {
    fn from(err: crate::error::UpdateResourceError) -> Self {
        match err.kind {
            crate::error::UpdateResourceErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateResourceErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateResourceErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateResourceErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateResourceErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateResourceErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateRestApiError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateRestApiError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateRestApiError> for Error {
    fn from(err: crate::error::UpdateRestApiError) -> Self {
        match err.kind {
            crate::error::UpdateRestApiErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateRestApiErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateRestApiErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateRestApiErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateRestApiErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateRestApiErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateRestApiErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateStageError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateStageError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateStageError> for Error {
    fn from(err: crate::error::UpdateStageError) -> Self {
        match err.kind {
            crate::error::UpdateStageErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateStageErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateStageErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateStageErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateStageErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateStageErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateStageErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateUsageError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateUsageError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateUsageError> for Error {
    fn from(err: crate::error::UpdateUsageError) -> Self {
        match err.kind {
            crate::error::UpdateUsageErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateUsageErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateUsageErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateUsageErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateUsageErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateUsageErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateUsageErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateUsagePlanError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateUsagePlanError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateUsagePlanError> for Error {
    fn from(err: crate::error::UpdateUsagePlanError) -> Self {
        match err.kind {
            crate::error::UpdateUsagePlanErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateUsagePlanErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateUsagePlanErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateUsagePlanErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateUsagePlanErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateUsagePlanErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateUsagePlanErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::error::UpdateVpcLinkError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: aws_smithy_http::result::SdkError<crate::error::UpdateVpcLinkError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(crate::error::Unhandled::new(err.into())),
        }
    }
}
impl From<crate::error::UpdateVpcLinkError> for Error {
    fn from(err: crate::error::UpdateVpcLinkError) -> Self {
        match err.kind {
            crate::error::UpdateVpcLinkErrorKind::BadRequestException(inner) => {
                Error::BadRequestException(inner)
            }
            crate::error::UpdateVpcLinkErrorKind::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::error::UpdateVpcLinkErrorKind::LimitExceededException(inner) => {
                Error::LimitExceededException(inner)
            }
            crate::error::UpdateVpcLinkErrorKind::NotFoundException(inner) => {
                Error::NotFoundException(inner)
            }
            crate::error::UpdateVpcLinkErrorKind::TooManyRequestsException(inner) => {
                Error::TooManyRequestsException(inner)
            }
            crate::error::UpdateVpcLinkErrorKind::UnauthorizedException(inner) => {
                Error::UnauthorizedException(inner)
            }
            crate::error::UpdateVpcLinkErrorKind::Unhandled(inner) => {
                Error::Unhandled(crate::error::Unhandled::new(inner.into()))
            }
        }
    }
}
impl std::error::Error for Error {}