import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/core/client";
import { ElasticLoadBalancingServiceException as __BaseException } from "./ElasticLoadBalancingServiceException";
/**
 * <p>The specified load balancer does not exist.</p>
 * @public
 */
export declare class AccessPointNotFoundException extends __BaseException {
    readonly name: "AccessPointNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AccessPointNotFoundException, __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 quota for the number of tags that can be assigned to a load balancer has been reached.</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 requested configuration change 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>One or more of the specified security groups do 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 VPC has no associated Internet gateway.</p>
 * @public
 */
export declare class InvalidSubnetException extends __BaseException {
    readonly name: "InvalidSubnetException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSubnetException, __BaseException>);
}
/**
 * <p>One or more of the specified subnets do 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>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>
 * @public
 */
export declare class CertificateNotFoundException extends __BaseException {
    readonly name: "CertificateNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<CertificateNotFoundException, __BaseException>);
}
/**
 * <p>A policy with the specified name already exists for this load balancer.</p>
 * @public
 */
export declare class DuplicatePolicyNameException extends __BaseException {
    readonly name: "DuplicatePolicyNameException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicatePolicyNameException, __BaseException>);
}
/**
 * <p>The quota for the number of policies for this load balancer has been reached.</p>
 * @public
 */
export declare class TooManyPoliciesException extends __BaseException {
    readonly name: "TooManyPoliciesException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyPoliciesException, __BaseException>);
}
/**
 * <p>The specified load balancer name already exists for this account.</p>
 * @public
 */
export declare class DuplicateAccessPointNameException extends __BaseException {
    readonly name: "DuplicateAccessPointNameException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicateAccessPointNameException, __BaseException>);
}
/**
 * <p>The specified value for the schema is not valid. You can only specify a scheme for load balancers in a VPC.</p>
 * @public
 */
export declare class InvalidSchemeException extends __BaseException {
    readonly name: "InvalidSchemeException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSchemeException, __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>The quota for the number of load balancers has been reached.</p>
 * @public
 */
export declare class TooManyAccessPointsException extends __BaseException {
    readonly name: "TooManyAccessPointsException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TooManyAccessPointsException, __BaseException>);
}
/**
 * <p>The specified protocol or signature version 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 listener already exists for the specified load balancer name and port, but with a different instance port, protocol, or SSL certificate.</p>
 * @public
 */
export declare class DuplicateListenerException extends __BaseException {
    readonly name: "DuplicateListenerException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DuplicateListenerException, __BaseException>);
}
/**
 * <p>One or more of the specified policy types do not exist.</p>
 * @public
 */
export declare class PolicyTypeNotFoundException extends __BaseException {
    readonly name: "PolicyTypeNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<PolicyTypeNotFoundException, __BaseException>);
}
/**
 * <p>A request made by Elastic Load Balancing to another service exceeds the maximum request rate permitted for your account.</p>
 * @public
 */
export declare class DependencyThrottleException extends __BaseException {
    readonly name: "DependencyThrottleException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DependencyThrottleException, __BaseException>);
}
/**
 * <p>The specified endpoint is not valid.</p>
 * @public
 */
export declare class InvalidEndPointException extends __BaseException {
    readonly name: "InvalidEndPointException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidEndPointException, __BaseException>);
}
/**
 * <p>The specified load balancer attribute does not exist.</p>
 * @public
 */
export declare class LoadBalancerAttributeNotFoundException extends __BaseException {
    readonly name: "LoadBalancerAttributeNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<LoadBalancerAttributeNotFoundException, __BaseException>);
}
/**
 * <p>One or more of the specified policies do not exist.</p>
 * @public
 */
export declare class PolicyNotFoundException extends __BaseException {
    readonly name: "PolicyNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<PolicyNotFoundException, __BaseException>);
}
/**
 * <p>The load balancer does not have a listener configured at the specified port.</p>
 * @public
 */
export declare class ListenerNotFoundException extends __BaseException {
    readonly name: "ListenerNotFoundException";
    readonly $fault: "client";
    Message?: string | undefined;
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ListenerNotFoundException, __BaseException>);
}