aws_sdk_licensemanager/

error_meta.rs

// 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>Access to resource denied.</p>
    AccessDeniedException(crate::types::error::AccessDeniedException),
    /// <p>The Amazon Web Services user account does not have permission to perform the action. Check the IAM policy associated with this account.</p>
    AuthorizationException(crate::types::error::AuthorizationException),
    /// <p>There was a conflict processing the request. Try your request again.</p>
    ConflictException(crate::types::error::ConflictException),
    /// <p>The entitlement is not allowed.</p>
    EntitlementNotAllowedException(crate::types::error::EntitlementNotAllowedException),
    /// <p>A dependency required to run the API is missing.</p>
    FailedDependencyException(crate::types::error::FailedDependencyException),
    /// <p>The request uses too many filters or too many filter values.</p>
    FilterLimitExceededException(crate::types::error::FilterLimitExceededException),
    /// <p>One or more parameter values are not valid.</p>
    InvalidParameterValueException(crate::types::error::InvalidParameterValueException),
    /// <p>License Manager cannot allocate a license to a resource because of its state.</p>
    /// <p>For example, you cannot allocate a license to an instance in the process of shutting down.</p>
    InvalidResourceStateException(crate::types::error::InvalidResourceStateException),
    /// <p>You do not have enough licenses available to support a new resource launch.</p>
    LicenseUsageException(crate::types::error::LicenseUsageException),
    /// <p>There are no entitlements found for this license, or the entitlement maximum count is reached.</p>
    NoEntitlementsAllowedException(crate::types::error::NoEntitlementsAllowedException),
    /// <p>Too many requests have been submitted. Try again after a brief wait.</p>
    RateLimitExceededException(crate::types::error::RateLimitExceededException),
    /// <p>This is not the correct Region for the resource. Try again.</p>
    RedirectException(crate::types::error::RedirectException),
    /// <p>Your resource limits have been exceeded.</p>
    ResourceLimitExceededException(crate::types::error::ResourceLimitExceededException),
    /// <p>The resource cannot be found.</p>
    ResourceNotFoundException(crate::types::error::ResourceNotFoundException),
    /// <p>The server experienced an internal error. Try again.</p>
    ServerInternalException(crate::types::error::ServerInternalException),
    /// <p>The digital signature method is unsupported. Try your request again.</p>
    UnsupportedDigitalSignatureMethodException(crate::types::error::UnsupportedDigitalSignatureMethodException),
    /// <p>The provided input is not valid. Try your request again.</p>
    ValidationException(crate::types::error::ValidationException),
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
    variable wildcard pattern and check `.code()`:
     \
    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
     \
    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-Error) for what information is available for the error.")]
    Unhandled(crate::error::sealed_unhandled::Unhandled),
}
impl ::std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::AccessDeniedException(inner) => inner.fmt(f),
            Error::AuthorizationException(inner) => inner.fmt(f),
            Error::ConflictException(inner) => inner.fmt(f),
            Error::EntitlementNotAllowedException(inner) => inner.fmt(f),
            Error::FailedDependencyException(inner) => inner.fmt(f),
            Error::FilterLimitExceededException(inner) => inner.fmt(f),
            Error::InvalidParameterValueException(inner) => inner.fmt(f),
            Error::InvalidResourceStateException(inner) => inner.fmt(f),
            Error::LicenseUsageException(inner) => inner.fmt(f),
            Error::NoEntitlementsAllowedException(inner) => inner.fmt(f),
            Error::RateLimitExceededException(inner) => inner.fmt(f),
            Error::RedirectException(inner) => inner.fmt(f),
            Error::ResourceLimitExceededException(inner) => inner.fmt(f),
            Error::ResourceNotFoundException(inner) => inner.fmt(f),
            Error::ServerInternalException(inner) => inner.fmt(f),
            Error::UnsupportedDigitalSignatureMethodException(inner) => inner.fmt(f),
            Error::ValidationException(inner) => inner.fmt(f),
            Error::Unhandled(_) => {
                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
                    write!(f, "unhandled error ({code})")
                } else {
                    f.write_str("unhandled error")
                }
            }
        }
    }
}
impl From<::aws_smithy_types::error::operation::BuildError> for Error {
    fn from(value: ::aws_smithy_types::error::operation::BuildError) -> Self {
        Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
            source: value.into(),
            meta: ::std::default::Default::default(),
        })
    }
}
impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for Error {
    fn meta(&self) -> &::aws_smithy_types::error::metadata::ErrorMetadata {
        match self {
            Self::AccessDeniedException(inner) => inner.meta(),
            Self::AuthorizationException(inner) => inner.meta(),
            Self::ConflictException(inner) => inner.meta(),
            Self::EntitlementNotAllowedException(inner) => inner.meta(),
            Self::FailedDependencyException(inner) => inner.meta(),
            Self::FilterLimitExceededException(inner) => inner.meta(),
            Self::InvalidParameterValueException(inner) => inner.meta(),
            Self::InvalidResourceStateException(inner) => inner.meta(),
            Self::LicenseUsageException(inner) => inner.meta(),
            Self::NoEntitlementsAllowedException(inner) => inner.meta(),
            Self::RateLimitExceededException(inner) => inner.meta(),
            Self::RedirectException(inner) => inner.meta(),
            Self::ResourceLimitExceededException(inner) => inner.meta(),
            Self::ResourceNotFoundException(inner) => inner.meta(),
            Self::ServerInternalException(inner) => inner.meta(),
            Self::UnsupportedDigitalSignatureMethodException(inner) => inner.meta(),
            Self::ValidationException(inner) => inner.meta(),
            Self::Unhandled(inner) => &inner.meta,
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::accept_grant::AcceptGrantError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::accept_grant::AcceptGrantError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::accept_grant::AcceptGrantError> for Error {
    fn from(err: crate::operation::accept_grant::AcceptGrantError) -> Self {
        match err {
            crate::operation::accept_grant::AcceptGrantError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::accept_grant::AcceptGrantError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::accept_grant::AcceptGrantError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::accept_grant::AcceptGrantError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::accept_grant::AcceptGrantError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
            crate::operation::accept_grant::AcceptGrantError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::accept_grant::AcceptGrantError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::accept_grant::AcceptGrantError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::check_in_license::CheckInLicenseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::check_in_license::CheckInLicenseError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::check_in_license::CheckInLicenseError> for Error {
    fn from(err: crate::operation::check_in_license::CheckInLicenseError) -> Self {
        match err {
            crate::operation::check_in_license::CheckInLicenseError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::check_in_license::CheckInLicenseError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::check_in_license::CheckInLicenseError::ConflictException(inner) => Error::ConflictException(inner),
            crate::operation::check_in_license::CheckInLicenseError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::check_in_license::CheckInLicenseError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::check_in_license::CheckInLicenseError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::check_in_license::CheckInLicenseError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::check_in_license::CheckInLicenseError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::check_in_license::CheckInLicenseError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError> for Error {
    fn from(err: crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError) -> Self {
        match err {
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::EntitlementNotAllowedException(inner) => {
                Error::EntitlementNotAllowedException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::NoEntitlementsAllowedException(inner) => {
                Error::NoEntitlementsAllowedException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::RedirectException(inner) => Error::RedirectException(inner),
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::UnsupportedDigitalSignatureMethodException(inner) => {
                Error::UnsupportedDigitalSignatureMethodException(inner)
            }
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::checkout_borrow_license::CheckoutBorrowLicenseError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::checkout_license::CheckoutLicenseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::checkout_license::CheckoutLicenseError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::checkout_license::CheckoutLicenseError> for Error {
    fn from(err: crate::operation::checkout_license::CheckoutLicenseError) -> Self {
        match err {
            crate::operation::checkout_license::CheckoutLicenseError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::checkout_license::CheckoutLicenseError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::checkout_license::CheckoutLicenseError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::checkout_license::CheckoutLicenseError::NoEntitlementsAllowedException(inner) => {
                Error::NoEntitlementsAllowedException(inner)
            }
            crate::operation::checkout_license::CheckoutLicenseError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::checkout_license::CheckoutLicenseError::RedirectException(inner) => Error::RedirectException(inner),
            crate::operation::checkout_license::CheckoutLicenseError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::checkout_license::CheckoutLicenseError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::checkout_license::CheckoutLicenseError::UnsupportedDigitalSignatureMethodException(inner) => {
                Error::UnsupportedDigitalSignatureMethodException(inner)
            }
            crate::operation::checkout_license::CheckoutLicenseError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::checkout_license::CheckoutLicenseError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_grant::CreateGrantError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_grant::CreateGrantError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_grant::CreateGrantError> for Error {
    fn from(err: crate::operation::create_grant::CreateGrantError) -> Self {
        match err {
            crate::operation::create_grant::CreateGrantError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::create_grant::CreateGrantError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::create_grant::CreateGrantError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::create_grant::CreateGrantError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::create_grant::CreateGrantError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
            crate::operation::create_grant::CreateGrantError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::create_grant::CreateGrantError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::create_grant::CreateGrantError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_grant_version::CreateGrantVersionError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_grant_version::CreateGrantVersionError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_grant_version::CreateGrantVersionError> for Error {
    fn from(err: crate::operation::create_grant_version::CreateGrantVersionError) -> Self {
        match err {
            crate::operation::create_grant_version::CreateGrantVersionError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::create_grant_version::CreateGrantVersionError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::create_grant_version::CreateGrantVersionError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::create_grant_version::CreateGrantVersionError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::create_grant_version::CreateGrantVersionError::ResourceLimitExceededException(inner) => {
                Error::ResourceLimitExceededException(inner)
            }
            crate::operation::create_grant_version::CreateGrantVersionError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::create_grant_version::CreateGrantVersionError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::create_grant_version::CreateGrantVersionError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license::CreateLicenseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license::CreateLicenseError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_license::CreateLicenseError> for Error {
    fn from(err: crate::operation::create_license::CreateLicenseError) -> Self {
        match err {
            crate::operation::create_license::CreateLicenseError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::create_license::CreateLicenseError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::create_license::CreateLicenseError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::create_license::CreateLicenseError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::create_license::CreateLicenseError::RedirectException(inner) => Error::RedirectException(inner),
            crate::operation::create_license::CreateLicenseError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::create_license::CreateLicenseError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::create_license::CreateLicenseError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_asset_group::CreateLicenseAssetGroupError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_asset_group::CreateLicenseAssetGroupError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_license_asset_group::CreateLicenseAssetGroupError> for Error {
    fn from(err: crate::operation::create_license_asset_group::CreateLicenseAssetGroupError) -> Self {
        match err {
            crate::operation::create_license_asset_group::CreateLicenseAssetGroupError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::create_license_asset_group::CreateLicenseAssetGroupError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::create_license_asset_group::CreateLicenseAssetGroupError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::create_license_asset_group::CreateLicenseAssetGroupError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::create_license_asset_group::CreateLicenseAssetGroupError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::create_license_asset_group::CreateLicenseAssetGroupError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::create_license_asset_group::CreateLicenseAssetGroupError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError> for Error {
    fn from(err: crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError) -> Self {
        match err {
            crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::create_license_asset_ruleset::CreateLicenseAssetRulesetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_configuration::CreateLicenseConfigurationError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_configuration::CreateLicenseConfigurationError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_license_configuration::CreateLicenseConfigurationError> for Error {
    fn from(err: crate::operation::create_license_configuration::CreateLicenseConfigurationError) -> Self {
        match err {
            crate::operation::create_license_configuration::CreateLicenseConfigurationError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::create_license_configuration::CreateLicenseConfigurationError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::create_license_configuration::CreateLicenseConfigurationError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::create_license_configuration::CreateLicenseConfigurationError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::create_license_configuration::CreateLicenseConfigurationError::ResourceLimitExceededException(inner) => {
                Error::ResourceLimitExceededException(inner)
            }
            crate::operation::create_license_configuration::CreateLicenseConfigurationError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::create_license_configuration::CreateLicenseConfigurationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError> for Error {
    fn from(err: crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError) -> Self {
        match err {
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::create_license_conversion_task_for_resource::CreateLicenseConversionTaskForResourceError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError> for Error {
    fn from(err: crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError) -> Self {
        match err {
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::InvalidParameterValueException(
                inner,
            ) => Error::InvalidParameterValueException(inner),
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::RateLimitExceededException(
                inner,
            ) => Error::RateLimitExceededException(inner),
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::ResourceLimitExceededException(
                inner,
            ) => Error::ResourceLimitExceededException(inner),
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::create_license_manager_report_generator::CreateLicenseManagerReportGeneratorError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_version::CreateLicenseVersionError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_license_version::CreateLicenseVersionError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_license_version::CreateLicenseVersionError> for Error {
    fn from(err: crate::operation::create_license_version::CreateLicenseVersionError) -> Self {
        match err {
            crate::operation::create_license_version::CreateLicenseVersionError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::create_license_version::CreateLicenseVersionError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::create_license_version::CreateLicenseVersionError::ConflictException(inner) => Error::ConflictException(inner),
            crate::operation::create_license_version::CreateLicenseVersionError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::create_license_version::CreateLicenseVersionError::RedirectException(inner) => Error::RedirectException(inner),
            crate::operation::create_license_version::CreateLicenseVersionError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::create_license_version::CreateLicenseVersionError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::create_license_version::CreateLicenseVersionError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::create_license_version::CreateLicenseVersionError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_token::CreateTokenError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::create_token::CreateTokenError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::create_token::CreateTokenError> for Error {
    fn from(err: crate::operation::create_token::CreateTokenError) -> Self {
        match err {
            crate::operation::create_token::CreateTokenError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::create_token::CreateTokenError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::create_token::CreateTokenError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::create_token::CreateTokenError::RedirectException(inner) => Error::RedirectException(inner),
            crate::operation::create_token::CreateTokenError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
            crate::operation::create_token::CreateTokenError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::create_token::CreateTokenError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::create_token::CreateTokenError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::create_token::CreateTokenError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_grant::DeleteGrantError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_grant::DeleteGrantError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::delete_grant::DeleteGrantError> for Error {
    fn from(err: crate::operation::delete_grant::DeleteGrantError) -> Self {
        match err {
            crate::operation::delete_grant::DeleteGrantError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::delete_grant::DeleteGrantError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::delete_grant::DeleteGrantError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::delete_grant::DeleteGrantError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::delete_grant::DeleteGrantError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
            crate::operation::delete_grant::DeleteGrantError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::delete_grant::DeleteGrantError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::delete_grant::DeleteGrantError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license::DeleteLicenseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license::DeleteLicenseError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::delete_license::DeleteLicenseError> for Error {
    fn from(err: crate::operation::delete_license::DeleteLicenseError) -> Self {
        match err {
            crate::operation::delete_license::DeleteLicenseError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::delete_license::DeleteLicenseError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::delete_license::DeleteLicenseError::ConflictException(inner) => Error::ConflictException(inner),
            crate::operation::delete_license::DeleteLicenseError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::delete_license::DeleteLicenseError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::delete_license::DeleteLicenseError::RedirectException(inner) => Error::RedirectException(inner),
            crate::operation::delete_license::DeleteLicenseError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::delete_license::DeleteLicenseError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::delete_license::DeleteLicenseError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError> for Error {
    fn from(err: crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError) -> Self {
        match err {
            crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::delete_license_asset_group::DeleteLicenseAssetGroupError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError> for Error {
    fn from(err: crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError) -> Self {
        match err {
            crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::delete_license_asset_ruleset::DeleteLicenseAssetRulesetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license_configuration::DeleteLicenseConfigurationError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_license_configuration::DeleteLicenseConfigurationError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::delete_license_configuration::DeleteLicenseConfigurationError> for Error {
    fn from(err: crate::operation::delete_license_configuration::DeleteLicenseConfigurationError) -> Self {
        match err {
            crate::operation::delete_license_configuration::DeleteLicenseConfigurationError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::delete_license_configuration::DeleteLicenseConfigurationError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::delete_license_configuration::DeleteLicenseConfigurationError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::delete_license_configuration::DeleteLicenseConfigurationError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::delete_license_configuration::DeleteLicenseConfigurationError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::delete_license_configuration::DeleteLicenseConfigurationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError> for Error {
    fn from(err: crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError) -> Self {
        match err {
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::InvalidParameterValueException(
                inner,
            ) => Error::InvalidParameterValueException(inner),
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::RateLimitExceededException(
                inner,
            ) => Error::RateLimitExceededException(inner),
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::ResourceLimitExceededException(
                inner,
            ) => Error::ResourceLimitExceededException(inner),
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::delete_license_manager_report_generator::DeleteLicenseManagerReportGeneratorError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_token::DeleteTokenError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::delete_token::DeleteTokenError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::delete_token::DeleteTokenError> for Error {
    fn from(err: crate::operation::delete_token::DeleteTokenError) -> Self {
        match err {
            crate::operation::delete_token::DeleteTokenError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::delete_token::DeleteTokenError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::delete_token::DeleteTokenError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::delete_token::DeleteTokenError::RedirectException(inner) => Error::RedirectException(inner),
            crate::operation::delete_token::DeleteTokenError::ResourceNotFoundException(inner) => Error::ResourceNotFoundException(inner),
            crate::operation::delete_token::DeleteTokenError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::delete_token::DeleteTokenError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::delete_token::DeleteTokenError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::extend_license_consumption::ExtendLicenseConsumptionError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::extend_license_consumption::ExtendLicenseConsumptionError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::extend_license_consumption::ExtendLicenseConsumptionError> for Error {
    fn from(err: crate::operation::extend_license_consumption::ExtendLicenseConsumptionError) -> Self {
        match err {
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::extend_license_consumption::ExtendLicenseConsumptionError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_access_token::GetAccessTokenError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_access_token::GetAccessTokenError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_access_token::GetAccessTokenError> for Error {
    fn from(err: crate::operation::get_access_token::GetAccessTokenError) -> Self {
        match err {
            crate::operation::get_access_token::GetAccessTokenError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::get_access_token::GetAccessTokenError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::get_access_token::GetAccessTokenError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::get_access_token::GetAccessTokenError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::get_access_token::GetAccessTokenError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::get_access_token::GetAccessTokenError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_grant::GetGrantError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_grant::GetGrantError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_grant::GetGrantError> for Error {
    fn from(err: crate::operation::get_grant::GetGrantError) -> Self {
        match err {
            crate::operation::get_grant::GetGrantError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::get_grant::GetGrantError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::get_grant::GetGrantError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::get_grant::GetGrantError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::get_grant::GetGrantError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
            crate::operation::get_grant::GetGrantError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::get_grant::GetGrantError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::get_grant::GetGrantError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license::GetLicenseError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license::GetLicenseError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_license::GetLicenseError> for Error {
    fn from(err: crate::operation::get_license::GetLicenseError) -> Self {
        match err {
            crate::operation::get_license::GetLicenseError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::get_license::GetLicenseError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::get_license::GetLicenseError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::get_license::GetLicenseError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::get_license::GetLicenseError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::get_license::GetLicenseError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::get_license::GetLicenseError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_asset_group::GetLicenseAssetGroupError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_asset_group::GetLicenseAssetGroupError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_license_asset_group::GetLicenseAssetGroupError> for Error {
    fn from(err: crate::operation::get_license_asset_group::GetLicenseAssetGroupError) -> Self {
        match err {
            crate::operation::get_license_asset_group::GetLicenseAssetGroupError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::get_license_asset_group::GetLicenseAssetGroupError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::get_license_asset_group::GetLicenseAssetGroupError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::get_license_asset_group::GetLicenseAssetGroupError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::get_license_asset_group::GetLicenseAssetGroupError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::get_license_asset_group::GetLicenseAssetGroupError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::get_license_asset_group::GetLicenseAssetGroupError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError> for Error {
    fn from(err: crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError) -> Self {
        match err {
            crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::get_license_asset_ruleset::GetLicenseAssetRulesetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_configuration::GetLicenseConfigurationError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_configuration::GetLicenseConfigurationError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_license_configuration::GetLicenseConfigurationError> for Error {
    fn from(err: crate::operation::get_license_configuration::GetLicenseConfigurationError) -> Self {
        match err {
            crate::operation::get_license_configuration::GetLicenseConfigurationError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::get_license_configuration::GetLicenseConfigurationError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::get_license_configuration::GetLicenseConfigurationError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::get_license_configuration::GetLicenseConfigurationError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::get_license_configuration::GetLicenseConfigurationError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::get_license_configuration::GetLicenseConfigurationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_conversion_task::GetLicenseConversionTaskError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_conversion_task::GetLicenseConversionTaskError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_license_conversion_task::GetLicenseConversionTaskError> for Error {
    fn from(err: crate::operation::get_license_conversion_task::GetLicenseConversionTaskError) -> Self {
        match err {
            crate::operation::get_license_conversion_task::GetLicenseConversionTaskError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::get_license_conversion_task::GetLicenseConversionTaskError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::get_license_conversion_task::GetLicenseConversionTaskError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::get_license_conversion_task::GetLicenseConversionTaskError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::get_license_conversion_task::GetLicenseConversionTaskError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::get_license_conversion_task::GetLicenseConversionTaskError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError> for Error {
    fn from(err: crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError) -> Self {
        match err {
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::ResourceLimitExceededException(inner) => {
                Error::ResourceLimitExceededException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::get_license_manager_report_generator::GetLicenseManagerReportGeneratorError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_usage::GetLicenseUsageError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_license_usage::GetLicenseUsageError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_license_usage::GetLicenseUsageError> for Error {
    fn from(err: crate::operation::get_license_usage::GetLicenseUsageError) -> Self {
        match err {
            crate::operation::get_license_usage::GetLicenseUsageError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::get_license_usage::GetLicenseUsageError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::get_license_usage::GetLicenseUsageError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::get_license_usage::GetLicenseUsageError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::get_license_usage::GetLicenseUsageError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::get_license_usage::GetLicenseUsageError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::get_license_usage::GetLicenseUsageError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_service_settings::GetServiceSettingsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_service_settings::GetServiceSettingsError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::get_service_settings::GetServiceSettingsError> for Error {
    fn from(err: crate::operation::get_service_settings::GetServiceSettingsError) -> Self {
        match err {
            crate::operation::get_service_settings::GetServiceSettingsError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::get_service_settings::GetServiceSettingsError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::get_service_settings::GetServiceSettingsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::get_service_settings::GetServiceSettingsError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::get_service_settings::GetServiceSettingsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError> for Error {
    fn from(err: crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError) -> Self {
        match err {
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::list_assets_for_license_asset_group::ListAssetsForLicenseAssetGroupError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError> for Error {
    fn from(err: crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError) -> Self {
        match err {
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError::FilterLimitExceededException(inner) => Error::FilterLimitExceededException(inner),
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::list_associations_for_license_configuration::ListAssociationsForLicenseConfigurationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_distributed_grants::ListDistributedGrantsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_distributed_grants::ListDistributedGrantsError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_distributed_grants::ListDistributedGrantsError> for Error {
    fn from(err: crate::operation::list_distributed_grants::ListDistributedGrantsError) -> Self {
        match err {
            crate::operation::list_distributed_grants::ListDistributedGrantsError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_distributed_grants::ListDistributedGrantsError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_distributed_grants::ListDistributedGrantsError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_distributed_grants::ListDistributedGrantsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_distributed_grants::ListDistributedGrantsError::ResourceLimitExceededException(inner) => {
                Error::ResourceLimitExceededException(inner)
            }
            crate::operation::list_distributed_grants::ListDistributedGrantsError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_distributed_grants::ListDistributedGrantsError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::list_distributed_grants::ListDistributedGrantsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError> for Error {
    fn from(err: crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError) -> Self {
        match err {
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::list_failures_for_license_configuration_operations::ListFailuresForLicenseConfigurationOperationsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError> for Error {
    fn from(err: crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError) -> Self {
        match err {
            crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::list_license_asset_groups::ListLicenseAssetGroupsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError> for Error {
    fn from(err: crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError) -> Self {
        match err {
            crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::list_license_asset_rulesets::ListLicenseAssetRulesetsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_configurations::ListLicenseConfigurationsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_configurations::ListLicenseConfigurationsError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_configurations::ListLicenseConfigurationsError> for Error {
    fn from(err: crate::operation::list_license_configurations::ListLicenseConfigurationsError) -> Self {
        match err {
            crate::operation::list_license_configurations::ListLicenseConfigurationsError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_license_configurations::ListLicenseConfigurationsError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_license_configurations::ListLicenseConfigurationsError::FilterLimitExceededException(inner) => {
                Error::FilterLimitExceededException(inner)
            }
            crate::operation::list_license_configurations::ListLicenseConfigurationsError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_license_configurations::ListLicenseConfigurationsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_license_configurations::ListLicenseConfigurationsError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_license_configurations::ListLicenseConfigurationsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError> for Error {
    fn from(err: crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError) -> Self {
        match err {
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError::FilterLimitExceededException(inner) => Error::FilterLimitExceededException(inner),
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::list_license_configurations_for_organization::ListLicenseConfigurationsForOrganizationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError> for Error {
    fn from(err: crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError) -> Self {
        match err {
            crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_license_conversion_tasks::ListLicenseConversionTasksError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError> for Error {
    fn from(err: crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError) -> Self {
        match err {
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::InvalidParameterValueException(
                inner,
            ) => Error::InvalidParameterValueException(inner),
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::ResourceLimitExceededException(
                inner,
            ) => Error::ResourceLimitExceededException(inner),
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::list_license_manager_report_generators::ListLicenseManagerReportGeneratorsError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_licenses::ListLicensesError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_licenses::ListLicensesError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_licenses::ListLicensesError> for Error {
    fn from(err: crate::operation::list_licenses::ListLicensesError) -> Self {
        match err {
            crate::operation::list_licenses::ListLicensesError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_licenses::ListLicensesError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_licenses::ListLicensesError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::list_licenses::ListLicensesError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::list_licenses::ListLicensesError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::list_licenses::ListLicensesError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::list_licenses::ListLicensesError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError> for Error {
    fn from(err: crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError) -> Self {
        match err {
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError::InvalidParameterValueException(
                inner,
            ) => Error::InvalidParameterValueException(inner),
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError::RateLimitExceededException(
                inner,
            ) => Error::RateLimitExceededException(inner),
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_license_specifications_for_resource::ListLicenseSpecificationsForResourceError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_versions::ListLicenseVersionsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_license_versions::ListLicenseVersionsError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_license_versions::ListLicenseVersionsError> for Error {
    fn from(err: crate::operation::list_license_versions::ListLicenseVersionsError) -> Self {
        match err {
            crate::operation::list_license_versions::ListLicenseVersionsError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_license_versions::ListLicenseVersionsError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_license_versions::ListLicenseVersionsError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_license_versions::ListLicenseVersionsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_license_versions::ListLicenseVersionsError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_license_versions::ListLicenseVersionsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_received_grants::ListReceivedGrantsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_received_grants::ListReceivedGrantsError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_received_grants::ListReceivedGrantsError> for Error {
    fn from(err: crate::operation::list_received_grants::ListReceivedGrantsError) -> Self {
        match err {
            crate::operation::list_received_grants::ListReceivedGrantsError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_received_grants::ListReceivedGrantsError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_received_grants::ListReceivedGrantsError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_received_grants::ListReceivedGrantsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_received_grants::ListReceivedGrantsError::ResourceLimitExceededException(inner) => {
                Error::ResourceLimitExceededException(inner)
            }
            crate::operation::list_received_grants::ListReceivedGrantsError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::list_received_grants::ListReceivedGrantsError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::list_received_grants::ListReceivedGrantsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError> for Error {
    fn from(err: crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError) -> Self {
        match err {
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::InvalidParameterValueException(
                inner,
            ) => Error::InvalidParameterValueException(inner),
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::ResourceLimitExceededException(
                inner,
            ) => Error::ResourceLimitExceededException(inner),
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::list_received_grants_for_organization::ListReceivedGrantsForOrganizationError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_received_licenses::ListReceivedLicensesError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_received_licenses::ListReceivedLicensesError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_received_licenses::ListReceivedLicensesError> for Error {
    fn from(err: crate::operation::list_received_licenses::ListReceivedLicensesError) -> Self {
        match err {
            crate::operation::list_received_licenses::ListReceivedLicensesError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_received_licenses::ListReceivedLicensesError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_received_licenses::ListReceivedLicensesError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_received_licenses::ListReceivedLicensesError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_received_licenses::ListReceivedLicensesError::ResourceLimitExceededException(inner) => {
                Error::ResourceLimitExceededException(inner)
            }
            crate::operation::list_received_licenses::ListReceivedLicensesError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_received_licenses::ListReceivedLicensesError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::list_received_licenses::ListReceivedLicensesError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError> for Error {
    fn from(err: crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError) -> Self {
        match err {
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::InvalidParameterValueException(
                inner,
            ) => Error::InvalidParameterValueException(inner),
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::RateLimitExceededException(
                inner,
            ) => Error::RateLimitExceededException(inner),
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::ResourceLimitExceededException(
                inner,
            ) => Error::ResourceLimitExceededException(inner),
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::list_received_licenses_for_organization::ListReceivedLicensesForOrganizationError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_resource_inventory::ListResourceInventoryError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_resource_inventory::ListResourceInventoryError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_resource_inventory::ListResourceInventoryError> for Error {
    fn from(err: crate::operation::list_resource_inventory::ListResourceInventoryError) -> Self {
        match err {
            crate::operation::list_resource_inventory::ListResourceInventoryError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_resource_inventory::ListResourceInventoryError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_resource_inventory::ListResourceInventoryError::FailedDependencyException(inner) => {
                Error::FailedDependencyException(inner)
            }
            crate::operation::list_resource_inventory::ListResourceInventoryError::FilterLimitExceededException(inner) => {
                Error::FilterLimitExceededException(inner)
            }
            crate::operation::list_resource_inventory::ListResourceInventoryError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_resource_inventory::ListResourceInventoryError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_resource_inventory::ListResourceInventoryError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_resource_inventory::ListResourceInventoryError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_tags_for_resource::ListTagsForResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_tags_for_resource::ListTagsForResourceError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_tags_for_resource::ListTagsForResourceError> for Error {
    fn from(err: crate::operation::list_tags_for_resource::ListTagsForResourceError) -> Self {
        match err {
            crate::operation::list_tags_for_resource::ListTagsForResourceError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_tags_for_resource::ListTagsForResourceError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_tags_for_resource::ListTagsForResourceError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_tags_for_resource::ListTagsForResourceError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_tags_for_resource::ListTagsForResourceError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_tags_for_resource::ListTagsForResourceError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::list_tags_for_resource::ListTagsForResourceError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_tokens::ListTokensError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::list_tokens::ListTokensError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_tokens::ListTokensError> for Error {
    fn from(err: crate::operation::list_tokens::ListTokensError) -> Self {
        match err {
            crate::operation::list_tokens::ListTokensError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::list_tokens::ListTokensError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::list_tokens::ListTokensError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::list_tokens::ListTokensError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::list_tokens::ListTokensError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::list_tokens::ListTokensError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError> for Error {
    fn from(err: crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError) -> Self {
        match err {
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError::FilterLimitExceededException(inner) => {
                Error::FilterLimitExceededException(inner)
            }
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::list_usage_for_license_configuration::ListUsageForLicenseConfigurationError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::reject_grant::RejectGrantError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::reject_grant::RejectGrantError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::reject_grant::RejectGrantError> for Error {
    fn from(err: crate::operation::reject_grant::RejectGrantError) -> Self {
        match err {
            crate::operation::reject_grant::RejectGrantError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::reject_grant::RejectGrantError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::reject_grant::RejectGrantError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::reject_grant::RejectGrantError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::reject_grant::RejectGrantError::ResourceLimitExceededException(inner) => Error::ResourceLimitExceededException(inner),
            crate::operation::reject_grant::RejectGrantError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::reject_grant::RejectGrantError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::reject_grant::RejectGrantError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::tag_resource::TagResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::tag_resource::TagResourceError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::tag_resource::TagResourceError> for Error {
    fn from(err: crate::operation::tag_resource::TagResourceError) -> Self {
        match err {
            crate::operation::tag_resource::TagResourceError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::tag_resource::TagResourceError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::tag_resource::TagResourceError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::tag_resource::TagResourceError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::tag_resource::TagResourceError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::tag_resource::TagResourceError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::tag_resource::TagResourceError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::untag_resource::UntagResourceError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::untag_resource::UntagResourceError, R>) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::untag_resource::UntagResourceError> for Error {
    fn from(err: crate::operation::untag_resource::UntagResourceError) -> Self {
        match err {
            crate::operation::untag_resource::UntagResourceError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::untag_resource::UntagResourceError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::untag_resource::UntagResourceError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::untag_resource::UntagResourceError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::untag_resource::UntagResourceError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::untag_resource::UntagResourceError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::untag_resource::UntagResourceError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError> for Error {
    fn from(err: crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError) -> Self {
        match err {
            crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::update_license_asset_group::UpdateLicenseAssetGroupError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError> for Error {
    fn from(err: crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError) -> Self {
        match err {
            crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::update_license_asset_ruleset::UpdateLicenseAssetRulesetError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_license_configuration::UpdateLicenseConfigurationError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_license_configuration::UpdateLicenseConfigurationError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::update_license_configuration::UpdateLicenseConfigurationError> for Error {
    fn from(err: crate::operation::update_license_configuration::UpdateLicenseConfigurationError) -> Self {
        match err {
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::ConflictException(inner) => {
                Error::ConflictException(inner)
            }
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::ResourceLimitExceededException(inner) => {
                Error::ResourceLimitExceededException(inner)
            }
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::update_license_configuration::UpdateLicenseConfigurationError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError> for Error {
    fn from(err: crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError) -> Self {
        match err {
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::InvalidParameterValueException(
                inner,
            ) => Error::InvalidParameterValueException(inner),
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::RateLimitExceededException(
                inner,
            ) => Error::RateLimitExceededException(inner),
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::ResourceLimitExceededException(
                inner,
            ) => Error::ResourceLimitExceededException(inner),
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::ResourceNotFoundException(inner) => {
                Error::ResourceNotFoundException(inner)
            }
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::ValidationException(inner) => {
                Error::ValidationException(inner)
            }
            crate::operation::update_license_manager_report_generator::UpdateLicenseManagerReportGeneratorError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError,
            R,
        >,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError> for Error {
    fn from(err: crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError) -> Self {
        match err {
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::AccessDeniedException(inner) => Error::AccessDeniedException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::AuthorizationException(inner) => Error::AuthorizationException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::ConflictException(inner) => Error::ConflictException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::InvalidParameterValueException(inner) => Error::InvalidParameterValueException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::InvalidResourceStateException(inner) => Error::InvalidResourceStateException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::LicenseUsageException(inner) => Error::LicenseUsageException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::RateLimitExceededException(inner) => Error::RateLimitExceededException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::ServerInternalException(inner) => Error::ServerInternalException(inner),
            crate::operation::update_license_specifications_for_resource::UpdateLicenseSpecificationsForResourceError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_service_settings::UpdateServiceSettingsError, R>> for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::update_service_settings::UpdateServiceSettingsError, R>,
    ) -> Self {
        match err {
            ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                source: err.into(),
            }),
        }
    }
}
impl From<crate::operation::update_service_settings::UpdateServiceSettingsError> for Error {
    fn from(err: crate::operation::update_service_settings::UpdateServiceSettingsError) -> Self {
        match err {
            crate::operation::update_service_settings::UpdateServiceSettingsError::AccessDeniedException(inner) => {
                Error::AccessDeniedException(inner)
            }
            crate::operation::update_service_settings::UpdateServiceSettingsError::AuthorizationException(inner) => {
                Error::AuthorizationException(inner)
            }
            crate::operation::update_service_settings::UpdateServiceSettingsError::ConflictException(inner) => Error::ConflictException(inner),
            crate::operation::update_service_settings::UpdateServiceSettingsError::InvalidParameterValueException(inner) => {
                Error::InvalidParameterValueException(inner)
            }
            crate::operation::update_service_settings::UpdateServiceSettingsError::RateLimitExceededException(inner) => {
                Error::RateLimitExceededException(inner)
            }
            crate::operation::update_service_settings::UpdateServiceSettingsError::ServerInternalException(inner) => {
                Error::ServerInternalException(inner)
            }
            crate::operation::update_service_settings::UpdateServiceSettingsError::ValidationException(inner) => Error::ValidationException(inner),
            crate::operation::update_service_settings::UpdateServiceSettingsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl ::std::error::Error for Error {
    fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
        match self {
            Error::AccessDeniedException(inner) => inner.source(),
            Error::AuthorizationException(inner) => inner.source(),
            Error::ConflictException(inner) => inner.source(),
            Error::EntitlementNotAllowedException(inner) => inner.source(),
            Error::FailedDependencyException(inner) => inner.source(),
            Error::FilterLimitExceededException(inner) => inner.source(),
            Error::InvalidParameterValueException(inner) => inner.source(),
            Error::InvalidResourceStateException(inner) => inner.source(),
            Error::LicenseUsageException(inner) => inner.source(),
            Error::NoEntitlementsAllowedException(inner) => inner.source(),
            Error::RateLimitExceededException(inner) => inner.source(),
            Error::RedirectException(inner) => inner.source(),
            Error::ResourceLimitExceededException(inner) => inner.source(),
            Error::ResourceNotFoundException(inner) => inner.source(),
            Error::ServerInternalException(inner) => inner.source(),
            Error::UnsupportedDigitalSignatureMethodException(inner) => inner.source(),
            Error::ValidationException(inner) => inner.source(),
            Error::Unhandled(inner) => ::std::option::Option::Some(&*inner.source),
        }
    }
}
impl ::aws_types::request_id::RequestId for Error {
    fn request_id(&self) -> Option<&str> {
        match self {
            Self::AccessDeniedException(e) => e.request_id(),
            Self::AuthorizationException(e) => e.request_id(),
            Self::ConflictException(e) => e.request_id(),
            Self::EntitlementNotAllowedException(e) => e.request_id(),
            Self::FailedDependencyException(e) => e.request_id(),
            Self::FilterLimitExceededException(e) => e.request_id(),
            Self::InvalidParameterValueException(e) => e.request_id(),
            Self::InvalidResourceStateException(e) => e.request_id(),
            Self::LicenseUsageException(e) => e.request_id(),
            Self::NoEntitlementsAllowedException(e) => e.request_id(),
            Self::RateLimitExceededException(e) => e.request_id(),
            Self::RedirectException(e) => e.request_id(),
            Self::ResourceLimitExceededException(e) => e.request_id(),
            Self::ResourceNotFoundException(e) => e.request_id(),
            Self::ServerInternalException(e) => e.request_id(),
            Self::UnsupportedDigitalSignatureMethodException(e) => e.request_id(),
            Self::ValidationException(e) => e.request_id(),
            Self::Unhandled(e) => e.meta.request_id(),
        }
    }
}