// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// All possible error types for this service.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum Error {
    /// <p>The specified load balancer does not exist.</p>
    AccessPointNotFoundException(crate::types::error::AccessPointNotFoundException),
    /// <p>The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded the certificate to IAM, this error might indicate that the certificate is not fully available yet.</p>
    CertificateNotFoundException(crate::types::error::CertificateNotFoundException),
    /// <p>A request made by Elastic Load Balancing to another service exceeds the maximum request rate permitted for your account.</p>
    DependencyThrottleException(crate::types::error::DependencyThrottleException),
    /// <p>The specified load balancer name already exists for this account.</p>
    DuplicateAccessPointNameException(crate::types::error::DuplicateAccessPointNameException),
    /// <p>A listener already exists for the specified load balancer name and port, but with a different instance port, protocol, or SSL certificate.</p>
    DuplicateListenerException(crate::types::error::DuplicateListenerException),
    /// <p>A policy with the specified name already exists for this load balancer.</p>
    DuplicatePolicyNameException(crate::types::error::DuplicatePolicyNameException),
    /// <p>A tag key was specified more than once.</p>
    DuplicateTagKeysException(crate::types::error::DuplicateTagKeysException),
    /// <p>The requested configuration change is not valid.</p>
    InvalidConfigurationRequestException(crate::types::error::InvalidConfigurationRequestException),
    /// <p>The specified endpoint is not valid.</p>
    InvalidEndPointException(crate::types::error::InvalidEndPointException),
    /// <p>The specified value for the schema is not valid. You can only specify a scheme for load balancers in a VPC.</p>
    InvalidSchemeException(crate::types::error::InvalidSchemeException),
    /// <p>One or more of the specified security groups do not exist.</p>
    InvalidSecurityGroupException(crate::types::error::InvalidSecurityGroupException),
    /// <p>The specified VPC has no associated Internet gateway.</p>
    InvalidSubnetException(crate::types::error::InvalidSubnetException),
    /// <p>The load balancer does not have a listener configured at the specified port.</p>
    ListenerNotFoundException(crate::types::error::ListenerNotFoundException),
    /// <p>The specified load balancer attribute does not exist.</p>
    LoadBalancerAttributeNotFoundException(
        crate::types::error::LoadBalancerAttributeNotFoundException,
    ),
    /// <p>This operation is not allowed.</p>
    OperationNotPermittedException(crate::types::error::OperationNotPermittedException),
    /// <p>One or more of the specified policies do not exist.</p>
    PolicyNotFoundException(crate::types::error::PolicyNotFoundException),
    /// <p>One or more of the specified policy types do not exist.</p>
    PolicyTypeNotFoundException(crate::types::error::PolicyTypeNotFoundException),
    /// <p>One or more of the specified subnets do not exist.</p>
    SubnetNotFoundException(crate::types::error::SubnetNotFoundException),
    /// <p>The quota for the number of load balancers has been reached.</p>
    TooManyAccessPointsException(crate::types::error::TooManyAccessPointsException),
    /// <p>The quota for the number of policies for this load balancer has been reached.</p>
    TooManyPoliciesException(crate::types::error::TooManyPoliciesException),
    /// <p>The quota for the number of tags that can be assigned to a load balancer has been reached.</p>
    TooManyTagsException(crate::types::error::TooManyTagsException),
    /// <p>The specified protocol or signature version is not supported.</p>
    UnsupportedProtocolException(crate::types::error::UnsupportedProtocolException),
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
    Unhandled(aws_smithy_types::error::Unhandled),
}
impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::AccessPointNotFoundException(inner) => inner.fmt(f),
            Error::CertificateNotFoundException(inner) => inner.fmt(f),
            Error::DependencyThrottleException(inner) => inner.fmt(f),
            Error::DuplicateAccessPointNameException(inner) => inner.fmt(f),
            Error::DuplicateListenerException(inner) => inner.fmt(f),
            Error::DuplicatePolicyNameException(inner) => inner.fmt(f),
            Error::DuplicateTagKeysException(inner) => inner.fmt(f),
            Error::InvalidConfigurationRequestException(inner) => inner.fmt(f),
            Error::InvalidEndPointException(inner) => inner.fmt(f),
            Error::InvalidSchemeException(inner) => inner.fmt(f),
            Error::InvalidSecurityGroupException(inner) => inner.fmt(f),
            Error::InvalidSubnetException(inner) => inner.fmt(f),
            Error::ListenerNotFoundException(inner) => inner.fmt(f),
            Error::LoadBalancerAttributeNotFoundException(inner) => inner.fmt(f),
            Error::OperationNotPermittedException(inner) => inner.fmt(f),
            Error::PolicyNotFoundException(inner) => inner.fmt(f),
            Error::PolicyTypeNotFoundException(inner) => inner.fmt(f),
            Error::SubnetNotFoundException(inner) => inner.fmt(f),
            Error::TooManyAccessPointsException(inner) => inner.fmt(f),
            Error::TooManyPoliciesException(inner) => inner.fmt(f),
            Error::TooManyTagsException(inner) => inner.fmt(f),
            Error::UnsupportedProtocolException(inner) => inner.fmt(f),
            Error::Unhandled(inner) => inner.fmt(f),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::add_tags::AddTagsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::add_tags::AddTagsError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::add_tags::AddTagsError> for Error {
    fn from(err: crate::operation::add_tags::AddTagsError) -> Self {
        match err {
            crate::operation::add_tags::AddTagsError::AccessPointNotFoundException(inner) => {
                Error::AccessPointNotFoundException(inner)
            }
            crate::operation::add_tags::AddTagsError::DuplicateTagKeysException(inner) => {
                Error::DuplicateTagKeysException(inner)
            }
            crate::operation::add_tags::AddTagsError::TooManyTagsException(inner) => {
                Error::TooManyTagsException(inner)
            }
            crate::operation::add_tags::AddTagsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError> for Error {
    fn from(err: crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError) -> Self {
        match err {
            crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::InvalidSecurityGroupException(inner) => Error::InvalidSecurityGroupException(inner),
            crate::operation::apply_security_groups_to_load_balancer::ApplySecurityGroupsToLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError>
    for Error
{
    fn from(
        err: crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError,
    ) -> Self {
        match err {
            crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::InvalidSubnetException(inner) => Error::InvalidSubnetException(inner),
            crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::SubnetNotFoundException(inner) => Error::SubnetNotFoundException(inner),
            crate::operation::attach_load_balancer_to_subnets::AttachLoadBalancerToSubnetsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::configure_health_check::ConfigureHealthCheckError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::configure_health_check::ConfigureHealthCheckError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::configure_health_check::ConfigureHealthCheckError> for Error {
    fn from(err: crate::operation::configure_health_check::ConfigureHealthCheckError) -> Self {
        match err {
            crate::operation::configure_health_check::ConfigureHealthCheckError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::configure_health_check::ConfigureHealthCheckError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl
    From<
        crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError,
    > for Error
{
    fn from(
        err: crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError,
    ) -> Self {
        match err {
            crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::DuplicatePolicyNameException(inner) => Error::DuplicatePolicyNameException(inner),
            crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::TooManyPoliciesException(inner) => Error::TooManyPoliciesException(inner),
            crate::operation::create_app_cookie_stickiness_policy::CreateAppCookieStickinessPolicyError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError>
    for Error
{
    fn from(
        err: crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError,
    ) -> Self {
        match err {
            crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::DuplicatePolicyNameException(inner) => Error::DuplicatePolicyNameException(inner),
            crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::TooManyPoliciesException(inner) => Error::TooManyPoliciesException(inner),
            crate::operation::create_lb_cookie_stickiness_policy::CreateLBCookieStickinessPolicyError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_load_balancer::CreateLoadBalancerError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_load_balancer::CreateLoadBalancerError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_load_balancer::CreateLoadBalancerError> for Error {
    fn from(err: crate::operation::create_load_balancer::CreateLoadBalancerError) -> Self {
        match err {
            crate::operation::create_load_balancer::CreateLoadBalancerError::CertificateNotFoundException(inner) => Error::CertificateNotFoundException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::DuplicateAccessPointNameException(inner) => Error::DuplicateAccessPointNameException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::DuplicateTagKeysException(inner) => Error::DuplicateTagKeysException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSchemeException(inner) => Error::InvalidSchemeException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSecurityGroupException(inner) => Error::InvalidSecurityGroupException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSubnetException(inner) => Error::InvalidSubnetException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::OperationNotPermittedException(inner) => Error::OperationNotPermittedException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::SubnetNotFoundException(inner) => Error::SubnetNotFoundException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::TooManyAccessPointsException(inner) => Error::TooManyAccessPointsException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::TooManyTagsException(inner) => Error::TooManyTagsException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::UnsupportedProtocolException(inner) => Error::UnsupportedProtocolException(inner),
            crate::operation::create_load_balancer::CreateLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError>
    for Error
{
    fn from(
        err: crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError,
    ) -> Self {
        match err {
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::CertificateNotFoundException(inner) => Error::CertificateNotFoundException(inner),
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::DuplicateListenerException(inner) => Error::DuplicateListenerException(inner),
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::UnsupportedProtocolException(inner) => Error::UnsupportedProtocolException(inner),
            crate::operation::create_load_balancer_listeners::CreateLoadBalancerListenersError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError> for Error {
    fn from(
        err: crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError,
    ) -> Self {
        match err {
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::DuplicatePolicyNameException(inner) => Error::DuplicatePolicyNameException(inner),
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::PolicyTypeNotFoundException(inner) => Error::PolicyTypeNotFoundException(inner),
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::TooManyPoliciesException(inner) => Error::TooManyPoliciesException(inner),
            crate::operation::create_load_balancer_policy::CreateLoadBalancerPolicyError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_load_balancer::DeleteLoadBalancerError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_load_balancer::DeleteLoadBalancerError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_load_balancer::DeleteLoadBalancerError> for Error {
    fn from(err: crate::operation::delete_load_balancer::DeleteLoadBalancerError) -> Self {
        match err {
            crate::operation::delete_load_balancer::DeleteLoadBalancerError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError>
    for Error
{
    fn from(
        err: crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError,
    ) -> Self {
        match err {
            crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::delete_load_balancer_listeners::DeleteLoadBalancerListenersError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError> for Error {
    fn from(
        err: crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError,
    ) -> Self {
        match err {
            crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::delete_load_balancer_policy::DeleteLoadBalancerPolicyError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError> for Error {
    fn from(err: crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError) -> Self {
        match err {
            crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError::InvalidEndPointException(inner) => Error::InvalidEndPointException(inner),
            crate::operation::deregister_instances_from_load_balancer::DeregisterInstancesFromLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_account_limits::DescribeAccountLimitsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_account_limits::DescribeAccountLimitsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_account_limits::DescribeAccountLimitsError> for Error {
    fn from(err: crate::operation::describe_account_limits::DescribeAccountLimitsError) -> Self {
        match err {
            crate::operation::describe_account_limits::DescribeAccountLimitsError::Unhandled(
                inner,
            ) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_instance_health::DescribeInstanceHealthError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_instance_health::DescribeInstanceHealthError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_instance_health::DescribeInstanceHealthError> for Error {
    fn from(err: crate::operation::describe_instance_health::DescribeInstanceHealthError) -> Self {
        match err {
            crate::operation::describe_instance_health::DescribeInstanceHealthError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::describe_instance_health::DescribeInstanceHealthError::InvalidEndPointException(inner) => Error::InvalidEndPointException(inner),
            crate::operation::describe_instance_health::DescribeInstanceHealthError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError>
    for Error
{
    fn from(
        err: crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError,
    ) -> Self {
        match err {
            crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError::LoadBalancerAttributeNotFoundException(inner) => Error::LoadBalancerAttributeNotFoundException(inner),
            crate::operation::describe_load_balancer_attributes::DescribeLoadBalancerAttributesError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError>
    for Error
{
    fn from(
        err: crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError,
    ) -> Self {
        match err {
            crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError::PolicyNotFoundException(inner) => Error::PolicyNotFoundException(inner),
            crate::operation::describe_load_balancer_policies::DescribeLoadBalancerPoliciesError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl
    From<
        crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError,
    > for Error
{
    fn from(
        err: crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError,
    ) -> Self {
        match err {
            crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError::PolicyTypeNotFoundException(inner) => Error::PolicyTypeNotFoundException(inner),
            crate::operation::describe_load_balancer_policy_types::DescribeLoadBalancerPolicyTypesError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::describe_load_balancers::DescribeLoadBalancersError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_load_balancers::DescribeLoadBalancersError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_load_balancers::DescribeLoadBalancersError> for Error {
    fn from(err: crate::operation::describe_load_balancers::DescribeLoadBalancersError) -> Self {
        match err {
            crate::operation::describe_load_balancers::DescribeLoadBalancersError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::describe_load_balancers::DescribeLoadBalancersError::DependencyThrottleException(inner) => Error::DependencyThrottleException(inner),
            crate::operation::describe_load_balancers::DescribeLoadBalancersError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<aws_smithy_http::result::SdkError<crate::operation::describe_tags::DescribeTagsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::describe_tags::DescribeTagsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::describe_tags::DescribeTagsError> for Error {
    fn from(err: crate::operation::describe_tags::DescribeTagsError) -> Self {
        match err {
            crate::operation::describe_tags::DescribeTagsError::AccessPointNotFoundException(
                inner,
            ) => Error::AccessPointNotFoundException(inner),
            crate::operation::describe_tags::DescribeTagsError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError>
    for Error
{
    fn from(
        err: crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError,
    ) -> Self {
        match err {
            crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::detach_load_balancer_from_subnets::DetachLoadBalancerFromSubnetsError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError> for Error {
    fn from(err: crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError) -> Self {
        match err {
            crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::disable_availability_zones_for_load_balancer::DisableAvailabilityZonesForLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError> for Error {
    fn from(err: crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError) -> Self {
        match err {
            crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::enable_availability_zones_for_load_balancer::EnableAvailabilityZonesForLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R>
    From<
        aws_smithy_http::result::SdkError<
            crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError,
            R,
        >,
    > for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<
            crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError,
            R,
        >,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError>
    for Error
{
    fn from(
        err: crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError,
    ) -> Self {
        match err {
            crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::LoadBalancerAttributeNotFoundException(inner) => Error::LoadBalancerAttributeNotFoundException(inner),
            crate::operation::modify_load_balancer_attributes::ModifyLoadBalancerAttributesError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError> for Error {
    fn from(err: crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError) -> Self {
        match err {
            crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError::InvalidEndPointException(inner) => Error::InvalidEndPointException(inner),
            crate::operation::register_instances_with_load_balancer::RegisterInstancesWithLoadBalancerError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::remove_tags::RemoveTagsError, R>>
    for Error
where
    R: Send + Sync + std::fmt::Debug + 'static,
{
    fn from(
        err: aws_smithy_http::result::SdkError<crate::operation::remove_tags::RemoveTagsError, R>,
    ) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => {
                Self::from(context.into_err())
            }
            _ => Error::Unhandled(
                aws_smithy_types::error::Unhandled::builder()
                    .meta(
                        aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                    )
                    .source(err)
                    .build(),
            ),
        }
    }
}
impl From<crate::operation::remove_tags::RemoveTagsError> for Error {
    fn from(err: crate::operation::remove_tags::RemoveTagsError) -> Self {
        match err {
            crate::operation::remove_tags::RemoveTagsError::AccessPointNotFoundException(inner) => {
                Error::AccessPointNotFoundException(inner)
            }
            crate::operation::remove_tags::RemoveTagsError::Unhandled(inner) => {
                Error::Unhandled(inner)
            }
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError> for Error {
    fn from(err: crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError) -> Self {
        match err {
            crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::CertificateNotFoundException(inner) => Error::CertificateNotFoundException(inner),
            crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::ListenerNotFoundException(inner) => Error::ListenerNotFoundException(inner),
            crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::UnsupportedProtocolException(inner) => Error::UnsupportedProtocolException(inner),
            crate::operation::set_load_balancer_listener_ssl_certificate::SetLoadBalancerListenerSSLCertificateError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError> for Error {
    fn from(err: crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError) -> Self {
        match err {
            crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::PolicyNotFoundException(inner) => Error::PolicyNotFoundException(inner),
            crate::operation::set_load_balancer_policies_for_backend_server::SetLoadBalancerPoliciesForBackendServerError::Unhandled(inner) => Error::Unhandled(inner),
        }
    }
}
impl<R> From<aws_smithy_http::result::SdkError<crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError, R>> for Error where R: Send + Sync + std::fmt::Debug + 'static {
    fn from(err: aws_smithy_http::result::SdkError<crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError, R>) -> Self {
        match err {
            aws_smithy_http::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
            _ => Error::Unhandled(
                                            aws_smithy_types::error::Unhandled::builder()
                                                .meta(aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone())
                                                .source(err)
                                                .build()
                                        ),
        }
    }
}
impl From<crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError> for Error {
    fn from(err: crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError) -> Self {
        match err {
            crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::AccessPointNotFoundException(inner) => Error::AccessPointNotFoundException(inner),
            crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::InvalidConfigurationRequestException(inner) => Error::InvalidConfigurationRequestException(inner),
            crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::ListenerNotFoundException(inner) => Error::ListenerNotFoundException(inner),
            crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::PolicyNotFoundException(inner) => Error::PolicyNotFoundException(inner),
            crate::operation::set_load_balancer_policies_of_listener::SetLoadBalancerPoliciesOfListenerError::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::AccessPointNotFoundException(inner) => inner.source(),
            Error::CertificateNotFoundException(inner) => inner.source(),
            Error::DependencyThrottleException(inner) => inner.source(),
            Error::DuplicateAccessPointNameException(inner) => inner.source(),
            Error::DuplicateListenerException(inner) => inner.source(),
            Error::DuplicatePolicyNameException(inner) => inner.source(),
            Error::DuplicateTagKeysException(inner) => inner.source(),
            Error::InvalidConfigurationRequestException(inner) => inner.source(),
            Error::InvalidEndPointException(inner) => inner.source(),
            Error::InvalidSchemeException(inner) => inner.source(),
            Error::InvalidSecurityGroupException(inner) => inner.source(),
            Error::InvalidSubnetException(inner) => inner.source(),
            Error::ListenerNotFoundException(inner) => inner.source(),
            Error::LoadBalancerAttributeNotFoundException(inner) => inner.source(),
            Error::OperationNotPermittedException(inner) => inner.source(),
            Error::PolicyNotFoundException(inner) => inner.source(),
            Error::PolicyTypeNotFoundException(inner) => inner.source(),
            Error::SubnetNotFoundException(inner) => inner.source(),
            Error::TooManyAccessPointsException(inner) => inner.source(),
            Error::TooManyPoliciesException(inner) => inner.source(),
            Error::TooManyTagsException(inner) => inner.source(),
            Error::UnsupportedProtocolException(inner) => inner.source(),
            Error::Unhandled(inner) => inner.source(),
        }
    }
}
impl aws_http::request_id::RequestId for Error {
    fn request_id(&self) -> Option<&str> {
        match self {
            Self::AccessPointNotFoundException(e) => e.request_id(),
            Self::CertificateNotFoundException(e) => e.request_id(),
            Self::DependencyThrottleException(e) => e.request_id(),
            Self::DuplicateAccessPointNameException(e) => e.request_id(),
            Self::DuplicateListenerException(e) => e.request_id(),
            Self::DuplicatePolicyNameException(e) => e.request_id(),
            Self::DuplicateTagKeysException(e) => e.request_id(),
            Self::InvalidConfigurationRequestException(e) => e.request_id(),
            Self::InvalidEndPointException(e) => e.request_id(),
            Self::InvalidSchemeException(e) => e.request_id(),
            Self::InvalidSecurityGroupException(e) => e.request_id(),
            Self::InvalidSubnetException(e) => e.request_id(),
            Self::ListenerNotFoundException(e) => e.request_id(),
            Self::LoadBalancerAttributeNotFoundException(e) => e.request_id(),
            Self::OperationNotPermittedException(e) => e.request_id(),
            Self::PolicyNotFoundException(e) => e.request_id(),
            Self::PolicyTypeNotFoundException(e) => e.request_id(),
            Self::SubnetNotFoundException(e) => e.request_id(),
            Self::TooManyAccessPointsException(e) => e.request_id(),
            Self::TooManyPoliciesException(e) => e.request_id(),
            Self::TooManyTagsException(e) => e.request_id(),
            Self::UnsupportedProtocolException(e) => e.request_id(),
            Self::Unhandled(e) => e.request_id(),
        }
    }
}