import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
import { ElasticLoadBalancingV2ServiceException as __BaseException } from "./ElasticLoadBalancingV2ServiceException";
/**
 * <p>The specified certificate does not exist.</p>
 * @public
 */
export declare class CertificateNotFoundException extends __BaseException {
    readonly name: "CertificateNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CertificateNotFoundException, __BaseException>);
}
/**
 * <p>The specified listener does not exist.</p>
 * @public
 */
export declare class ListenerNotFoundException extends __BaseException {
    readonly name: "ListenerNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ListenerNotFoundException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of certificates per load balancer.</p>
 * @public
 */
export declare class TooManyCertificatesException extends __BaseException {
    readonly name: "TooManyCertificatesException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyCertificatesException, __BaseException>);
}
/**
 * <p>A tag key was specified more than once.</p>
 * @public
 */
export declare class DuplicateTagKeysException extends __BaseException {
    readonly name: "DuplicateTagKeysException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicateTagKeysException, __BaseException>);
}
/**
 * <p>The specified load balancer does not exist.</p>
 * @public
 */
export declare class LoadBalancerNotFoundException extends __BaseException {
    readonly name: "LoadBalancerNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<LoadBalancerNotFoundException, __BaseException>);
}
/**
 * <p>The specified rule does not exist.</p>
 * @public
 */
export declare class RuleNotFoundException extends __BaseException {
    readonly name: "RuleNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RuleNotFoundException, __BaseException>);
}
/**
 * <p>The specified target group does not exist.</p>
 * @public
 */
export declare class TargetGroupNotFoundException extends __BaseException {
    readonly name: "TargetGroupNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TargetGroupNotFoundException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of tags for this resource.</p>
 * @public
 */
export declare class TooManyTagsException extends __BaseException {
    readonly name: "TooManyTagsException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
}
/**
 * <p>The specified trust store does not exist.</p>
 * @public
 */
export declare class TrustStoreNotFoundException extends __BaseException {
    readonly name: "TrustStoreNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TrustStoreNotFoundException, __BaseException>);
}
/**
 * <p>The provided revocation file is an invalid format, or uses an incorrect algorithm.</p>
 * @public
 */
export declare class InvalidRevocationContentException extends __BaseException {
    readonly name: "InvalidRevocationContentException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRevocationContentException, __BaseException>);
}
/**
 * <p>The specified revocation file does not exist.</p>
 * @public
 */
export declare class RevocationContentNotFoundException extends __BaseException {
    readonly name: "RevocationContentNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RevocationContentNotFoundException, __BaseException>);
}
/**
 * <p>The specified trust store has too many revocation entries.</p>
 * @public
 */
export declare class TooManyTrustStoreRevocationEntriesException extends __BaseException {
    readonly name: "TooManyTrustStoreRevocationEntriesException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyTrustStoreRevocationEntriesException, __BaseException>);
}
/**
 * <p>The specified allocation ID does not exist.</p>
 * @public
 */
export declare class AllocationIdNotFoundException extends __BaseException {
    readonly name: "AllocationIdNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AllocationIdNotFoundException, __BaseException>);
}
/**
 * <p>The specified ALPN policy is not supported.</p>
 * @public
 */
export declare class ALPNPolicyNotSupportedException extends __BaseException {
    readonly name: "ALPNPolicyNotSupportedException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ALPNPolicyNotSupportedException, __BaseException>);
}
/**
 * <p>The specified Availability Zone is not supported.</p>
 * @public
 */
export declare class AvailabilityZoneNotSupportedException extends __BaseException {
    readonly name: "AvailabilityZoneNotSupportedException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AvailabilityZoneNotSupportedException, __BaseException>);
}
/**
 * <p>The specified ca certificate bundle does not exist.</p>
 * @public
 */
export declare class CaCertificatesBundleNotFoundException extends __BaseException {
    readonly name: "CaCertificatesBundleNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CaCertificatesBundleNotFoundException, __BaseException>);
}
/**
 * <p>You've exceeded the daily capacity decrease limit for this reservation.</p>
 * @public
 */
export declare class CapacityDecreaseRequestsLimitExceededException extends __BaseException {
    readonly name: "CapacityDecreaseRequestsLimitExceededException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CapacityDecreaseRequestsLimitExceededException, __BaseException>);
}
/**
 * <p>There is a pending capacity reservation.</p>
 * @public
 */
export declare class CapacityReservationPendingException extends __BaseException {
    readonly name: "CapacityReservationPendingException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CapacityReservationPendingException, __BaseException>);
}
/**
 * <p>You've exceeded the capacity units limit.</p>
 * @public
 */
export declare class CapacityUnitsLimitExceededException extends __BaseException {
    readonly name: "CapacityUnitsLimitExceededException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CapacityUnitsLimitExceededException, __BaseException>);
}
/**
 * <p>A listener with the specified port already exists.</p>
 * @public
 */
export declare class DuplicateListenerException extends __BaseException {
    readonly name: "DuplicateListenerException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicateListenerException, __BaseException>);
}
/**
 * <p>The specified configuration is not valid with this protocol.</p>
 * @public
 */
export declare class IncompatibleProtocolsException extends __BaseException {
    readonly name: "IncompatibleProtocolsException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IncompatibleProtocolsException, __BaseException>);
}
/**
 * <p>The requested configuration is not valid.</p>
 * @public
 */
export declare class InvalidConfigurationRequestException extends __BaseException {
    readonly name: "InvalidConfigurationRequestException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidConfigurationRequestException, __BaseException>);
}
/**
 * <p>The requested action is not valid.</p>
 * @public
 */
export declare class InvalidLoadBalancerActionException extends __BaseException {
    readonly name: "InvalidLoadBalancerActionException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidLoadBalancerActionException, __BaseException>);
}
/**
 * <p>The specified SSL policy does not exist.</p>
 * @public
 */
export declare class SSLPolicyNotFoundException extends __BaseException {
    readonly name: "SSLPolicyNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SSLPolicyNotFoundException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of load balancers per target group.</p>
 * @public
 */
export declare class TargetGroupAssociationLimitException extends __BaseException {
    readonly name: "TargetGroupAssociationLimitException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TargetGroupAssociationLimitException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of actions per rule.</p>
 * @public
 */
export declare class TooManyActionsException extends __BaseException {
    readonly name: "TooManyActionsException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyActionsException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of listeners per load balancer.</p>
 * @public
 */
export declare class TooManyListenersException extends __BaseException {
    readonly name: "TooManyListenersException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyListenersException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of times a target can be registered with a load
 *       balancer.</p>
 * @public
 */
export declare class TooManyRegistrationsForTargetIdException extends __BaseException {
    readonly name: "TooManyRegistrationsForTargetIdException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyRegistrationsForTargetIdException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of targets.</p>
 * @public
 */
export declare class TooManyTargetsException extends __BaseException {
    readonly name: "TooManyTargetsException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyTargetsException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of unique target groups per load balancer across
 *       all listeners. If a target group is used by multiple actions for a load balancer, it is
 *       counted as only one use.</p>
 * @public
 */
export declare class TooManyUniqueTargetGroupsPerLoadBalancerException extends __BaseException {
    readonly name: "TooManyUniqueTargetGroupsPerLoadBalancerException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyUniqueTargetGroupsPerLoadBalancerException, __BaseException>);
}
/**
 * <p>The specified trust store is not active.</p>
 * @public
 */
export declare class TrustStoreNotReadyException extends __BaseException {
    readonly name: "TrustStoreNotReadyException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TrustStoreNotReadyException, __BaseException>);
}
/**
 * <p>The specified protocol is not supported.</p>
 * @public
 */
export declare class UnsupportedProtocolException extends __BaseException {
    readonly name: "UnsupportedProtocolException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnsupportedProtocolException, __BaseException>);
}
/**
 * <p>A load balancer with the specified name already exists.</p>
 * @public
 */
export declare class DuplicateLoadBalancerNameException extends __BaseException {
    readonly name: "DuplicateLoadBalancerNameException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicateLoadBalancerNameException, __BaseException>);
}
/**
 * <p>The requested scheme is not valid.</p>
 * @public
 */
export declare class InvalidSchemeException extends __BaseException {
    readonly name: "InvalidSchemeException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSchemeException, __BaseException>);
}
/**
 * <p>The specified security group does not exist.</p>
 * @public
 */
export declare class InvalidSecurityGroupException extends __BaseException {
    readonly name: "InvalidSecurityGroupException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSecurityGroupException, __BaseException>);
}
/**
 * <p>The specified subnet is out of available addresses.</p>
 * @public
 */
export declare class InvalidSubnetException extends __BaseException {
    readonly name: "InvalidSubnetException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSubnetException, __BaseException>);
}
/**
 * <p>This operation is not allowed.</p>
 * @public
 */
export declare class OperationNotPermittedException extends __BaseException {
    readonly name: "OperationNotPermittedException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<OperationNotPermittedException, __BaseException>);
}
/**
 * <p>A specified resource is in use.</p>
 * @public
 */
export declare class ResourceInUseException extends __BaseException {
    readonly name: "ResourceInUseException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
}
/**
 * <p>The specified subnet does not exist.</p>
 * @public
 */
export declare class SubnetNotFoundException extends __BaseException {
    readonly name: "SubnetNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<SubnetNotFoundException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of load balancers for your Amazon Web Services
 *       account.</p>
 * @public
 */
export declare class TooManyLoadBalancersException extends __BaseException {
    readonly name: "TooManyLoadBalancersException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyLoadBalancersException, __BaseException>);
}
/**
 * <p>The specified priority is in use.</p>
 * @public
 */
export declare class PriorityInUseException extends __BaseException {
    readonly name: "PriorityInUseException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<PriorityInUseException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of rules per load balancer.</p>
 * @public
 */
export declare class TooManyRulesException extends __BaseException {
    readonly name: "TooManyRulesException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyRulesException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of target groups for your Amazon Web Services
 *       account.</p>
 * @public
 */
export declare class TooManyTargetGroupsException extends __BaseException {
    readonly name: "TooManyTargetGroupsException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyTargetGroupsException, __BaseException>);
}
/**
 * <p>A target group with the specified name already exists.</p>
 * @public
 */
export declare class DuplicateTargetGroupNameException extends __BaseException {
    readonly name: "DuplicateTargetGroupNameException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicateTargetGroupNameException, __BaseException>);
}
/**
 * <p>A trust store with the specified name already exists.</p>
 * @public
 */
export declare class DuplicateTrustStoreNameException extends __BaseException {
    readonly name: "DuplicateTrustStoreNameException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicateTrustStoreNameException, __BaseException>);
}
/**
 * <p>The specified ca certificate bundle is in an invalid format, or corrupt.</p>
 * @public
 */
export declare class InvalidCaCertificatesBundleException extends __BaseException {
    readonly name: "InvalidCaCertificatesBundleException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidCaCertificatesBundleException, __BaseException>);
}
/**
 * <p>You've reached the limit on the number of trust stores for your Amazon Web Services account.</p>
 * @public
 */
export declare class TooManyTrustStoresException extends __BaseException {
    readonly name: "TooManyTrustStoresException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyTrustStoresException, __BaseException>);
}
/**
 * <p>The specified association can't be within the same account.</p>
 * @public
 */
export declare class DeleteAssociationSameAccountException extends __BaseException {
    readonly name: "DeleteAssociationSameAccountException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeleteAssociationSameAccountException, __BaseException>);
}
/**
 * <p>The specified association does not exist.</p>
 * @public
 */
export declare class TrustStoreAssociationNotFoundException extends __BaseException {
    readonly name: "TrustStoreAssociationNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TrustStoreAssociationNotFoundException, __BaseException>);
}
/**
 * <p>The specified trust store is currently in use.</p>
 * @public
 */
export declare class TrustStoreInUseException extends __BaseException {
    readonly name: "TrustStoreInUseException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TrustStoreInUseException, __BaseException>);
}
/**
 * <p>The specified target does not exist, is not in the same VPC as the target group, or has an
 *       unsupported instance type.</p>
 * @public
 */
export declare class InvalidTargetException extends __BaseException {
    readonly name: "InvalidTargetException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTargetException, __BaseException>);
}
/**
 * <p>The health of the specified targets could not be retrieved due to an internal
 *       error.</p>
 * @public
 */
export declare class HealthUnavailableException extends __BaseException {
    readonly name: "HealthUnavailableException";
    readonly $fault: "server";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<HealthUnavailableException, __BaseException>);
}
/**
 * <p>The specified revocation ID does not exist.</p>
 * @public
 */
export declare class RevocationIdNotFoundException extends __BaseException {
    readonly name: "RevocationIdNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RevocationIdNotFoundException, __BaseException>);
}
/**
 * <p>The specified resource does not exist.</p>
 * @public
 */
export declare class ResourceNotFoundException extends __BaseException {
    readonly name: "ResourceNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
}
/**
 * <p>There is insufficient capacity to reserve.</p>
 * @public
 */
export declare class InsufficientCapacityException extends __BaseException {
    readonly name: "InsufficientCapacityException";
    readonly $fault: "server";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InsufficientCapacityException, __BaseException>);
}
/**
 * <p>This operation is not allowed while a prior request has not been completed.</p>
 * @public
 */
export declare class PriorRequestNotCompleteException extends __BaseException {
    readonly name: "PriorRequestNotCompleteException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<PriorRequestNotCompleteException, __BaseException>);
}