@aws-sdk/client-elastic-load-balancing-v2 3.50.0 → 3.53.0

package/dist-types/index.d.ts

@@ -4,3 +4,4 @@ export * from "./commands";
 export * from "./models";
 export * from "./pagination";
 export * from "./waiters";
+export { ElasticLoadBalancingV2ServiceException } from "./models/ElasticLoadBalancingV2ServiceException";

package/dist-types/models/ElasticLoadBalancingV2ServiceException.d.ts

@@ -0,0 +1,10 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+/**
+ * Base exception class for all service exceptions from ElasticLoadBalancingV2 service.
+ */
+export declare class ElasticLoadBalancingV2ServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/models/models_0.d.ts

@@ -1,4 +1,5 @@
-import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ElasticLoadBalancingV2ServiceException as __BaseException } from "./ElasticLoadBalancingV2ServiceException";
 export declare enum AuthenticateCognitoActionConditionalBehaviorEnum {
     ALLOW = "allow",
     AUTHENTICATE = "authenticate",
@@ -432,26 +433,38 @@ export declare namespace AddListenerCertificatesOutput {
 /**
  * <p>The specified certificate does not exist.</p>
  */
-export interface CertificateNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "CertificateNotFoundException";
-    $fault: "client";
+export declare class CertificateNotFoundException extends __BaseException {
+    readonly name: "CertificateNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CertificateNotFoundException, __BaseException>);
 }
 /**
  * <p>The specified listener does not exist.</p>
  */
-export interface ListenerNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "ListenerNotFoundException";
-    $fault: "client";
+export declare class ListenerNotFoundException extends __BaseException {
+    readonly name: "ListenerNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ListenerNotFoundException, __BaseException>);
 }
 /**
  * <p>You've reached the limit on the number of certificates per load balancer.</p>
  */
-export interface TooManyCertificatesException extends __SmithyException, $MetadataBearer {
-    name: "TooManyCertificatesException";
-    $fault: "client";
+export declare class TooManyCertificatesException extends __BaseException {
+    readonly name: "TooManyCertificatesException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyCertificatesException, __BaseException>);
 }
 /**
  * <p>Information about a tag.</p>
@@ -499,58 +512,86 @@ export declare namespace AddTagsOutput {
 /**
  * <p>A tag key was specified more than once.</p>
  */
-export interface DuplicateTagKeysException extends __SmithyException, $MetadataBearer {
-    name: "DuplicateTagKeysException";
-    $fault: "client";
+export declare class DuplicateTagKeysException extends __BaseException {
+    readonly name: "DuplicateTagKeysException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DuplicateTagKeysException, __BaseException>);
 }
 /**
  * <p>The specified load balancer does not exist.</p>
  */
-export interface LoadBalancerNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "LoadBalancerNotFoundException";
-    $fault: "client";
+export declare class LoadBalancerNotFoundException extends __BaseException {
+    readonly name: "LoadBalancerNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LoadBalancerNotFoundException, __BaseException>);
 }
 /**
  * <p>The specified rule does not exist.</p>
  */
-export interface RuleNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "RuleNotFoundException";
-    $fault: "client";
+export declare class RuleNotFoundException extends __BaseException {
+    readonly name: "RuleNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<RuleNotFoundException, __BaseException>);
 }
 /**
  * <p>The specified target group does not exist.</p>
  */
-export interface TargetGroupNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "TargetGroupNotFoundException";
-    $fault: "client";
+export declare class TargetGroupNotFoundException extends __BaseException {
+    readonly name: "TargetGroupNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TargetGroupNotFoundException, __BaseException>);
 }
 /**
  * <p>You've reached the limit on the number of tags per load balancer.</p>
  */
-export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
-    name: "TooManyTagsException";
-    $fault: "client";
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
 }
 /**
  * <p>The specified allocation ID does not exist.</p>
  */
-export interface AllocationIdNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "AllocationIdNotFoundException";
-    $fault: "client";
+export declare class AllocationIdNotFoundException extends __BaseException {
+    readonly name: "AllocationIdNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AllocationIdNotFoundException, __BaseException>);
 }
 /**
  * <p>The specified ALPN policy is not supported.</p>
  */
-export interface ALPNPolicyNotSupportedException extends __SmithyException, $MetadataBearer {
-    name: "ALPNPolicyNotSupportedException";
-    $fault: "client";
+export declare class ALPNPolicyNotSupportedException extends __BaseException {
+    readonly name: "ALPNPolicyNotSupportedException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ALPNPolicyNotSupportedException, __BaseException>);
 }
 /**
  * <p>Information about a static IP address for a load balancer.</p>
@@ -613,10 +654,14 @@ export declare namespace AvailabilityZone {
 /**
  * <p>The specified Availability Zone is not supported.</p>
  */
-export interface AvailabilityZoneNotSupportedException extends __SmithyException, $MetadataBearer {
-    name: "AvailabilityZoneNotSupportedException";
-    $fault: "client";
+export declare class AvailabilityZoneNotSupportedException extends __BaseException {
+    readonly name: "AvailabilityZoneNotSupportedException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AvailabilityZoneNotSupportedException, __BaseException>);
 }
 /**
  * <p>Information about a cipher used in a policy.</p>
@@ -778,101 +823,149 @@ export declare namespace CreateListenerOutput {
 /**
  * <p>A listener with the specified port already exists.</p>
  */
-export interface DuplicateListenerException extends __SmithyException, $MetadataBearer {
-    name: "DuplicateListenerException";
-    $fault: "client";
+export declare class DuplicateListenerException extends __BaseException {
+    readonly name: "DuplicateListenerException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DuplicateListenerException, __BaseException>);
 }
 /**
  * <p>The specified configuration is not valid with this protocol.</p>
  */
-export interface IncompatibleProtocolsException extends __SmithyException, $MetadataBearer {
-    name: "IncompatibleProtocolsException";
-    $fault: "client";
+export declare class IncompatibleProtocolsException extends __BaseException {
+    readonly name: "IncompatibleProtocolsException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IncompatibleProtocolsException, __BaseException>);
 }
 /**
  * <p>The requested configuration is not valid.</p>
  */
-export interface InvalidConfigurationRequestException extends __SmithyException, $MetadataBearer {
-    name: "InvalidConfigurationRequestException";
-    $fault: "client";
+export declare class InvalidConfigurationRequestException extends __BaseException {
+    readonly name: "InvalidConfigurationRequestException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidConfigurationRequestException, __BaseException>);
 }
 /**
  * <p>The requested action is not valid.</p>
  */
-export interface InvalidLoadBalancerActionException extends __SmithyException, $MetadataBearer {
-    name: "InvalidLoadBalancerActionException";
-    $fault: "client";
+export declare class InvalidLoadBalancerActionException extends __BaseException {
+    readonly name: "InvalidLoadBalancerActionException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidLoadBalancerActionException, __BaseException>);
 }
 /**
  * <p>The specified SSL policy does not exist.</p>
  */
-export interface SSLPolicyNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "SSLPolicyNotFoundException";
-    $fault: "client";
+export declare class SSLPolicyNotFoundException extends __BaseException {
+    readonly name: "SSLPolicyNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SSLPolicyNotFoundException, __BaseException>);
 }
 /**
  * <p>You've reached the limit on the number of load balancers per target group.</p>
  */
-export interface TargetGroupAssociationLimitException extends __SmithyException, $MetadataBearer {
-    name: "TargetGroupAssociationLimitException";
-    $fault: "client";
+export declare class TargetGroupAssociationLimitException extends __BaseException {
+    readonly name: "TargetGroupAssociationLimitException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TargetGroupAssociationLimitException, __BaseException>);
 }
 /**
  * <p>You've reached the limit on the number of actions per rule.</p>
  */
-export interface TooManyActionsException extends __SmithyException, $MetadataBearer {
-    name: "TooManyActionsException";
-    $fault: "client";
+export declare class TooManyActionsException extends __BaseException {
+    readonly name: "TooManyActionsException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyActionsException, __BaseException>);
 }
 /**
  * <p>You've reached the limit on the number of listeners per load balancer.</p>
  */
-export interface TooManyListenersException extends __SmithyException, $MetadataBearer {
-    name: "TooManyListenersException";
-    $fault: "client";
+export declare class TooManyListenersException extends __BaseException {
+    readonly name: "TooManyListenersException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @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>
  */
-export interface TooManyRegistrationsForTargetIdException extends __SmithyException, $MetadataBearer {
-    name: "TooManyRegistrationsForTargetIdException";
-    $fault: "client";
+export declare class TooManyRegistrationsForTargetIdException extends __BaseException {
+    readonly name: "TooManyRegistrationsForTargetIdException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyRegistrationsForTargetIdException, __BaseException>);
 }
 /**
  * <p>You've reached the limit on the number of targets.</p>
  */
-export interface TooManyTargetsException extends __SmithyException, $MetadataBearer {
-    name: "TooManyTargetsException";
-    $fault: "client";
+export declare class TooManyTargetsException extends __BaseException {
+    readonly name: "TooManyTargetsException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @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>
  */
-export interface TooManyUniqueTargetGroupsPerLoadBalancerException extends __SmithyException, $MetadataBearer {
-    name: "TooManyUniqueTargetGroupsPerLoadBalancerException";
-    $fault: "client";
+export declare class TooManyUniqueTargetGroupsPerLoadBalancerException extends __BaseException {
+    readonly name: "TooManyUniqueTargetGroupsPerLoadBalancerException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyUniqueTargetGroupsPerLoadBalancerException, __BaseException>);
 }
 /**
  * <p>The specified protocol is not supported.</p>
  */
-export interface UnsupportedProtocolException extends __SmithyException, $MetadataBearer {
-    name: "UnsupportedProtocolException";
-    $fault: "client";
+export declare class UnsupportedProtocolException extends __BaseException {
+    readonly name: "UnsupportedProtocolException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnsupportedProtocolException, __BaseException>);
 }
 export declare enum IpAddressType {
     DUALSTACK = "dualstack",
@@ -1113,67 +1206,99 @@ export declare namespace CreateLoadBalancerOutput {
 /**
  * <p>A load balancer with the specified name already exists.</p>
  */
-export interface DuplicateLoadBalancerNameException extends __SmithyException, $MetadataBearer {
-    name: "DuplicateLoadBalancerNameException";
-    $fault: "client";
+export declare class DuplicateLoadBalancerNameException extends __BaseException {
+    readonly name: "DuplicateLoadBalancerNameException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DuplicateLoadBalancerNameException, __BaseException>);
 }
 /**
  * <p>The requested scheme is not valid.</p>
  */
-export interface InvalidSchemeException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSchemeException";
-    $fault: "client";
+export declare class InvalidSchemeException extends __BaseException {
+    readonly name: "InvalidSchemeException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSchemeException, __BaseException>);
 }
 /**
  * <p>The specified security group does not exist.</p>
  */
-export interface InvalidSecurityGroupException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSecurityGroupException";
-    $fault: "client";
+export declare class InvalidSecurityGroupException extends __BaseException {
+    readonly name: "InvalidSecurityGroupException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSecurityGroupException, __BaseException>);
 }
 /**
  * <p>The specified subnet is out of available addresses.</p>
  */
-export interface InvalidSubnetException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSubnetException";
-    $fault: "client";
+export declare class InvalidSubnetException extends __BaseException {
+    readonly name: "InvalidSubnetException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSubnetException, __BaseException>);
 }
 /**
  * <p>This operation is not allowed.</p>
  */
-export interface OperationNotPermittedException extends __SmithyException, $MetadataBearer {
-    name: "OperationNotPermittedException";
-    $fault: "client";
+export declare class OperationNotPermittedException extends __BaseException {
+    readonly name: "OperationNotPermittedException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<OperationNotPermittedException, __BaseException>);
 }
 /**
  * <p>A specified resource is in use.</p>
  */
-export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
-    name: "ResourceInUseException";
-    $fault: "client";
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
 }
 /**
  * <p>The specified subnet does not exist.</p>
  */
-export interface SubnetNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "SubnetNotFoundException";
-    $fault: "client";
+export declare class SubnetNotFoundException extends __BaseException {
+    readonly name: "SubnetNotFoundException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @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>
  */
-export interface TooManyLoadBalancersException extends __SmithyException, $MetadataBearer {
-    name: "TooManyLoadBalancersException";
-    $fault: "client";
+export declare class TooManyLoadBalancersException extends __BaseException {
+    readonly name: "TooManyLoadBalancersException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyLoadBalancersException, __BaseException>);
 }
 /**
  * <p>Information about a host header condition.</p>
@@ -1541,27 +1666,39 @@ export declare namespace CreateRuleOutput {
 /**
  * <p>The specified priority is in use.</p>
  */
-export interface PriorityInUseException extends __SmithyException, $MetadataBearer {
-    name: "PriorityInUseException";
-    $fault: "client";
+export declare class PriorityInUseException extends __BaseException {
+    readonly name: "PriorityInUseException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<PriorityInUseException, __BaseException>);
 }
 /**
  * <p>You've reached the limit on the number of rules per load balancer.</p>
  */
-export interface TooManyRulesException extends __SmithyException, $MetadataBearer {
-    name: "TooManyRulesException";
-    $fault: "client";
+export declare class TooManyRulesException extends __BaseException {
+    readonly name: "TooManyRulesException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @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>
  */
-export interface TooManyTargetGroupsException extends __SmithyException, $MetadataBearer {
-    name: "TooManyTargetGroupsException";
-    $fault: "client";
+export declare class TooManyTargetGroupsException extends __BaseException {
+    readonly name: "TooManyTargetGroupsException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyTargetGroupsException, __BaseException>);
 }
 export declare enum TargetGroupIpAddressTypeEnum {
     IPV4 = "ipv4",
@@ -1854,10 +1991,14 @@ export declare namespace CreateTargetGroupOutput {
 /**
  * <p>A target group with the specified name already exists.</p>
  */
-export interface DuplicateTargetGroupNameException extends __SmithyException, $MetadataBearer {
-    name: "DuplicateTargetGroupNameException";
-    $fault: "client";
+export declare class DuplicateTargetGroupNameException extends __BaseException {
+    readonly name: "DuplicateTargetGroupNameException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DuplicateTargetGroupNameException, __BaseException>);
 }
 export interface DeleteListenerInput {
     /**
@@ -2009,10 +2150,14 @@ export declare namespace DeregisterTargetsOutput {
  * <p>The specified target does not exist, is not in the same VPC as the target group, or has an
  *       unsupported instance type.</p>
  */
-export interface InvalidTargetException extends __SmithyException, $MetadataBearer {
-    name: "InvalidTargetException";
-    $fault: "client";
+export declare class InvalidTargetException extends __BaseException {
+    readonly name: "InvalidTargetException";
+    readonly $fault: "client";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidTargetException, __BaseException>);
 }
 export interface DescribeAccountLimitsInput {
     /**
@@ -2942,10 +3087,14 @@ export declare namespace DescribeTargetHealthOutput {
  * <p>The health of the specified targets could not be retrieved due to an internal
  *       error.</p>
  */
-export interface HealthUnavailableException extends __SmithyException, $MetadataBearer {
-    name: "HealthUnavailableException";
-    $fault: "server";
+export declare class HealthUnavailableException extends __BaseException {
+    readonly name: "HealthUnavailableException";
+    readonly $fault: "server";
     Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<HealthUnavailableException, __BaseException>);
 }
 export interface ModifyListenerInput {
     /**