@aws-sdk/client-elastic-load-balancing 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/CreateLBCookieStickinessPolicyCommand.d.ts

@@ -1,41 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { CreateLBCookieStickinessPolicyInput, CreateLBCookieStickinessPolicyOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLBCookieStickinessPolicyCommandInput extends CreateLBCookieStickinessPolicyInput {
-}
-export interface CreateLBCookieStickinessPolicyCommandOutput extends CreateLBCookieStickinessPolicyOutput, __MetadataBearer {
-}
-/**
- * <p>Generates a stickiness policy with sticky session lifetimes controlled by the lifetime of the browser (user-agent) or a specified expiration period. This policy can be associated only with HTTP/HTTPS listeners.</p>
- *         <p>When a load balancer implements this policy, the load balancer uses a special cookie to track the instance for each request. When the load balancer receives a request, it first checks to see if this cookie is present in the request.
- *             If so, the load balancer sends the request to the application server specified in the cookie. If not, the load balancer sends the request to a server that is chosen based on the existing load-balancing algorithm.</p>
- *         <p>A cookie is inserted into the response for binding subsequent requests from the same user to that server. The validity of the cookie is based on the cookie expiration time, which is specified in the policy configuration.</p>
- *
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-duration">Duration-Based Session Stickiness</a>
- *             in the <i>Classic Load Balancers Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, CreateLBCookieStickinessPolicyCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, CreateLBCookieStickinessPolicyCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new CreateLBCookieStickinessPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLBCookieStickinessPolicyCommandInput} for command's `input` shape.
- * @see {@link CreateLBCookieStickinessPolicyCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLBCookieStickinessPolicyCommand extends $Command<CreateLBCookieStickinessPolicyCommandInput, CreateLBCookieStickinessPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateLBCookieStickinessPolicyCommandInput;
-    constructor(input: CreateLBCookieStickinessPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLBCookieStickinessPolicyCommandInput, CreateLBCookieStickinessPolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLoadBalancerCommand.d.ts

@@ -1,48 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { CreateAccessPointInput, CreateAccessPointOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLoadBalancerCommandInput extends CreateAccessPointInput {
-}
-export interface CreateLoadBalancerCommandOutput extends CreateAccessPointOutput, __MetadataBearer {
-}
-/**
- * <p>Creates a Classic Load Balancer.</p>
- *
- *         <p>You can add listeners, security groups, subnets, and tags when you create your load balancer,
- *             or you can add them later using <a>CreateLoadBalancerListeners</a>,
- *             <a>ApplySecurityGroupsToLoadBalancer</a>, <a>AttachLoadBalancerToSubnets</a>,
- *             and <a>AddTags</a>.</p>
- *         <p>To describe your current load balancers, see <a>DescribeLoadBalancers</a>.
- *             When you are finished with a load balancer, you can delete it using
- *             <a>DeleteLoadBalancer</a>.</p>
- *
- *         <p>You can create up to 20 load balancers per region per account.
- *             You can request an increase for the number of load balancers for your account.
- *             For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-limits.html">Limits for Your Classic Load Balancer</a>
- *             in the <i>Classic Load Balancers Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, CreateLoadBalancerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, CreateLoadBalancerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new CreateLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link CreateLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLoadBalancerCommand extends $Command<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateLoadBalancerCommandInput;
-    constructor(input: CreateLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLoadBalancerListenersCommand.d.ts

@@ -1,37 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { CreateLoadBalancerListenerInput, CreateLoadBalancerListenerOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLoadBalancerListenersCommandInput extends CreateLoadBalancerListenerInput {
-}
-export interface CreateLoadBalancerListenersCommandOutput extends CreateLoadBalancerListenerOutput, __MetadataBearer {
-}
-/**
- * <p>Creates one or more listeners for the specified load balancer. If a listener with the specified port does not already exist, it is created; otherwise, the properties of the new listener must match the properties of the existing listener.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html">Listeners for Your Classic Load Balancer</a>
- *             in the <i>Classic Load Balancers Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, CreateLoadBalancerListenersCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, CreateLoadBalancerListenersCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new CreateLoadBalancerListenersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoadBalancerListenersCommandInput} for command's `input` shape.
- * @see {@link CreateLoadBalancerListenersCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLoadBalancerListenersCommand extends $Command<CreateLoadBalancerListenersCommandInput, CreateLoadBalancerListenersCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateLoadBalancerListenersCommandInput;
-    constructor(input: CreateLoadBalancerListenersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerListenersCommandInput, CreateLoadBalancerListenersCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLoadBalancerPolicyCommand.d.ts

@@ -1,36 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { CreateLoadBalancerPolicyInput, CreateLoadBalancerPolicyOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLoadBalancerPolicyCommandInput extends CreateLoadBalancerPolicyInput {
-}
-export interface CreateLoadBalancerPolicyCommandOutput extends CreateLoadBalancerPolicyOutput, __MetadataBearer {
-}
-/**
- * <p>Creates a policy with the specified attributes for the specified load balancer.</p>
- *          <p>Policies are settings that are saved for your load balancer and that can be applied to the listener or the application server, depending on the policy type.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, CreateLoadBalancerPolicyCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, CreateLoadBalancerPolicyCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new CreateLoadBalancerPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoadBalancerPolicyCommandInput} for command's `input` shape.
- * @see {@link CreateLoadBalancerPolicyCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLoadBalancerPolicyCommand extends $Command<CreateLoadBalancerPolicyCommandInput, CreateLoadBalancerPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateLoadBalancerPolicyCommandInput;
-    constructor(input: CreateLoadBalancerPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerPolicyCommandInput, CreateLoadBalancerPolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteLoadBalancerCommand.d.ts

@@ -1,38 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DeleteAccessPointInput, DeleteAccessPointOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteLoadBalancerCommandInput extends DeleteAccessPointInput {
-}
-export interface DeleteLoadBalancerCommandOutput extends DeleteAccessPointOutput, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified load balancer.</p>
- *         <p>If you are attempting to recreate a load balancer, you must reconfigure all settings. The DNS name associated with a deleted load balancer are no longer usable. The name and associated DNS record of the deleted load balancer no longer exist and traffic sent to any of its IP addresses is no longer delivered to your instances.</p>
- *         <p>If the load balancer does not exist or has already been deleted, the call to
- *             <code>DeleteLoadBalancer</code> still succeeds.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DeleteLoadBalancerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DeleteLoadBalancerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DeleteLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link DeleteLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteLoadBalancerCommand extends $Command<DeleteLoadBalancerCommandInput, DeleteLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DeleteLoadBalancerCommandInput;
-    constructor(input: DeleteLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoadBalancerCommandInput, DeleteLoadBalancerCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteLoadBalancerPolicyCommand.d.ts

@@ -1,35 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DeleteLoadBalancerPolicyInput, DeleteLoadBalancerPolicyOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteLoadBalancerPolicyCommandInput extends DeleteLoadBalancerPolicyInput {
-}
-export interface DeleteLoadBalancerPolicyCommandOutput extends DeleteLoadBalancerPolicyOutput, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified policy from the specified load balancer. This policy must not be enabled for any listeners.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DeleteLoadBalancerPolicyCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DeleteLoadBalancerPolicyCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DeleteLoadBalancerPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLoadBalancerPolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteLoadBalancerPolicyCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteLoadBalancerPolicyCommand extends $Command<DeleteLoadBalancerPolicyCommandInput, DeleteLoadBalancerPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DeleteLoadBalancerPolicyCommandInput;
-    constructor(input: DeleteLoadBalancerPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoadBalancerPolicyCommandInput, DeleteLoadBalancerPolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeregisterInstancesFromLoadBalancerCommand.d.ts

@@ -1,40 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DeregisterEndPointsInput, DeregisterEndPointsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeregisterInstancesFromLoadBalancerCommandInput extends DeregisterEndPointsInput {
-}
-export interface DeregisterInstancesFromLoadBalancerCommandOutput extends DeregisterEndPointsOutput, __MetadataBearer {
-}
-/**
- * <p>Deregisters the specified instances from the specified load balancer. After the instance is deregistered, it no longer receives traffic from the load balancer.</p>
- *
- *         <p>You can use <a>DescribeLoadBalancers</a> to verify that the instance is deregistered from the load balancer.</p>
- *
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-deregister-register-instances.html">Register or De-Register EC2 Instances</a>
- *             in the <i>Classic Load Balancers Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DeregisterInstancesFromLoadBalancerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DeregisterInstancesFromLoadBalancerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DeregisterInstancesFromLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterInstancesFromLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link DeregisterInstancesFromLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeregisterInstancesFromLoadBalancerCommand extends $Command<DeregisterInstancesFromLoadBalancerCommandInput, DeregisterInstancesFromLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DeregisterInstancesFromLoadBalancerCommandInput;
-    constructor(input: DeregisterInstancesFromLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterInstancesFromLoadBalancerCommandInput, DeregisterInstancesFromLoadBalancerCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeAccountLimitsCommand.d.ts

@@ -1,37 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DescribeAccountLimitsInput, DescribeAccountLimitsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeAccountLimitsCommandInput extends DescribeAccountLimitsInput {
-}
-export interface DescribeAccountLimitsCommandOutput extends DescribeAccountLimitsOutput, __MetadataBearer {
-}
-/**
- * <p>Describes the current Elastic Load Balancing resource limits for your AWS account.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-limits.html">Limits for Your Classic Load Balancer</a>
- *             in the <i>Classic Load Balancers Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DescribeAccountLimitsCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DescribeAccountLimitsCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DescribeAccountLimitsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccountLimitsCommandInput} for command's `input` shape.
- * @see {@link DescribeAccountLimitsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeAccountLimitsCommand extends $Command<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DescribeAccountLimitsCommandInput;
-    constructor(input: DescribeAccountLimitsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeInstanceHealthCommand.d.ts

@@ -1,35 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DescribeEndPointStateInput, DescribeEndPointStateOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeInstanceHealthCommandInput extends DescribeEndPointStateInput {
-}
-export interface DescribeInstanceHealthCommandOutput extends DescribeEndPointStateOutput, __MetadataBearer {
-}
-/**
- * <p>Describes the state of the specified instances with respect to the specified load balancer. If no instances are specified, the call describes the state of all instances that are currently registered with the load balancer. If instances are specified, their state is returned even if they are no longer registered with the load balancer. The state of terminated instances is not returned.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DescribeInstanceHealthCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DescribeInstanceHealthCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DescribeInstanceHealthCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeInstanceHealthCommandInput} for command's `input` shape.
- * @see {@link DescribeInstanceHealthCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeInstanceHealthCommand extends $Command<DescribeInstanceHealthCommandInput, DescribeInstanceHealthCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DescribeInstanceHealthCommandInput;
-    constructor(input: DescribeInstanceHealthCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInstanceHealthCommandInput, DescribeInstanceHealthCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeLoadBalancerPoliciesCommand.d.ts

@@ -1,39 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DescribeLoadBalancerPoliciesInput, DescribeLoadBalancerPoliciesOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeLoadBalancerPoliciesCommandInput extends DescribeLoadBalancerPoliciesInput {
-}
-export interface DescribeLoadBalancerPoliciesCommandOutput extends DescribeLoadBalancerPoliciesOutput, __MetadataBearer {
-}
-/**
- * <p>Describes the specified policies.</p>
- *          <p>If you specify a load balancer name, the action returns the descriptions of all policies created for the load balancer.
- *     If you specify a policy name associated with your load balancer, the action returns the description of that policy.
- *     If you don't specify a load balancer name, the action returns descriptions of the specified sample policies, or descriptions of all sample policies.
- *     The names of the sample policies have the <code>ELBSample-</code> prefix.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DescribeLoadBalancerPoliciesCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DescribeLoadBalancerPoliciesCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DescribeLoadBalancerPoliciesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLoadBalancerPoliciesCommandInput} for command's `input` shape.
- * @see {@link DescribeLoadBalancerPoliciesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeLoadBalancerPoliciesCommand extends $Command<DescribeLoadBalancerPoliciesCommandInput, DescribeLoadBalancerPoliciesCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DescribeLoadBalancerPoliciesCommandInput;
-    constructor(input: DescribeLoadBalancerPoliciesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancerPoliciesCommandInput, DescribeLoadBalancerPoliciesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeLoadBalancerPolicyTypesCommand.d.ts

@@ -1,42 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DescribeLoadBalancerPolicyTypesInput, DescribeLoadBalancerPolicyTypesOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeLoadBalancerPolicyTypesCommandInput extends DescribeLoadBalancerPolicyTypesInput {
-}
-export interface DescribeLoadBalancerPolicyTypesCommandOutput extends DescribeLoadBalancerPolicyTypesOutput, __MetadataBearer {
-}
-/**
- * <p>Describes the specified load balancer policy types or all load balancer policy types.</p>
- *          <p>The description of each type indicates how it can be used. For example,
- *            some policies can be used only with layer 7 listeners,
- *            some policies can be used only with layer 4 listeners,
- *            and some policies can be used only with your EC2 instances.</p>
- *          <p>You can use <a>CreateLoadBalancerPolicy</a> to create a policy configuration for any of these policy types.
- *            Then, depending on the policy type, use either <a>SetLoadBalancerPoliciesOfListener</a> or
- *            <a>SetLoadBalancerPoliciesForBackendServer</a> to set the policy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DescribeLoadBalancerPolicyTypesCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DescribeLoadBalancerPolicyTypesCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DescribeLoadBalancerPolicyTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLoadBalancerPolicyTypesCommandInput} for command's `input` shape.
- * @see {@link DescribeLoadBalancerPolicyTypesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeLoadBalancerPolicyTypesCommand extends $Command<DescribeLoadBalancerPolicyTypesCommandInput, DescribeLoadBalancerPolicyTypesCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DescribeLoadBalancerPolicyTypesCommandInput;
-    constructor(input: DescribeLoadBalancerPolicyTypesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancerPolicyTypesCommandInput, DescribeLoadBalancerPolicyTypesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeLoadBalancersCommand.d.ts

@@ -1,35 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DescribeAccessPointsInput, DescribeAccessPointsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeLoadBalancersCommandInput extends DescribeAccessPointsInput {
-}
-export interface DescribeLoadBalancersCommandOutput extends DescribeAccessPointsOutput, __MetadataBearer {
-}
-/**
- * <p>Describes the specified the load balancers. If no load balancers are specified, the call describes all of your load balancers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DescribeLoadBalancersCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DescribeLoadBalancersCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DescribeLoadBalancersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLoadBalancersCommandInput} for command's `input` shape.
- * @see {@link DescribeLoadBalancersCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeLoadBalancersCommand extends $Command<DescribeLoadBalancersCommandInput, DescribeLoadBalancersCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DescribeLoadBalancersCommandInput;
-    constructor(input: DescribeLoadBalancersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancersCommandInput, DescribeLoadBalancersCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeTagsCommand.d.ts

@@ -1,35 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DescribeTagsInput, DescribeTagsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeTagsCommandInput extends DescribeTagsInput {
-}
-export interface DescribeTagsCommandOutput extends DescribeTagsOutput, __MetadataBearer {
-}
-/**
- * <p>Describes the tags associated with the specified load balancers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DescribeTagsCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DescribeTagsCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DescribeTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTagsCommandInput} for command's `input` shape.
- * @see {@link DescribeTagsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeTagsCommand extends $Command<DescribeTagsCommandInput, DescribeTagsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DescribeTagsCommandInput;
-    constructor(input: DescribeTagsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTagsCommandInput, DescribeTagsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DetachLoadBalancerFromSubnetsCommand.d.ts

@@ -1,38 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { DetachLoadBalancerFromSubnetsInput, DetachLoadBalancerFromSubnetsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DetachLoadBalancerFromSubnetsCommandInput extends DetachLoadBalancerFromSubnetsInput {
-}
-export interface DetachLoadBalancerFromSubnetsCommandOutput extends DetachLoadBalancerFromSubnetsOutput, __MetadataBearer {
-}
-/**
- * <p>Removes the specified subnets from the set of configured subnets for the load balancer.</p>
- *         <p>After a subnet is removed, all EC2 instances registered with the load balancer
- *             in the removed subnet go into the <code>OutOfService</code> state. Then,
- *             the load balancer balances the traffic among the remaining routable subnets.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DetachLoadBalancerFromSubnetsCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DetachLoadBalancerFromSubnetsCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DetachLoadBalancerFromSubnetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetachLoadBalancerFromSubnetsCommandInput} for command's `input` shape.
- * @see {@link DetachLoadBalancerFromSubnetsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DetachLoadBalancerFromSubnetsCommand extends $Command<DetachLoadBalancerFromSubnetsCommandInput, DetachLoadBalancerFromSubnetsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DetachLoadBalancerFromSubnetsCommandInput;
-    constructor(input: DetachLoadBalancerFromSubnetsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachLoadBalancerFromSubnetsCommandInput, DetachLoadBalancerFromSubnetsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DisableAvailabilityZonesForLoadBalancerCommand.d.ts

@@ -1,43 +0,0 @@
-import { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
-import { RemoveAvailabilityZonesInput, RemoveAvailabilityZonesOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DisableAvailabilityZonesForLoadBalancerCommandInput extends RemoveAvailabilityZonesInput {
-}
-export interface DisableAvailabilityZonesForLoadBalancerCommandOutput extends RemoveAvailabilityZonesOutput, __MetadataBearer {
-}
-/**
- * <p>Removes the specified Availability Zones from the set of Availability Zones for the specified load balancer
- *             in EC2-Classic or a default VPC.</p>
- *         <p>For load balancers in a non-default VPC, use <a>DetachLoadBalancerFromSubnets</a>.</p>
- *         <p>There must be at least one Availability Zone registered with a load balancer at all times.
- *          After an Availability Zone is removed, all instances registered with the load balancer that are in the removed
- *          Availability Zone go into the <code>OutOfService</code> state. Then, the load balancer attempts to equally balance
- *          the traffic among its remaining Availability Zones.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-az.html">Add or Remove Availability Zones</a>
- *             in the <i>Classic Load Balancers Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DisableAvailabilityZonesForLoadBalancerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DisableAvailabilityZonesForLoadBalancerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DisableAvailabilityZonesForLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DisableAvailabilityZonesForLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link DisableAvailabilityZonesForLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DisableAvailabilityZonesForLoadBalancerCommand extends $Command<DisableAvailabilityZonesForLoadBalancerCommandInput, DisableAvailabilityZonesForLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: DisableAvailabilityZonesForLoadBalancerCommandInput;
-    constructor(input: DisableAvailabilityZonesForLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableAvailabilityZonesForLoadBalancerCommandInput, DisableAvailabilityZonesForLoadBalancerCommandOutput>;
-    private serialize;
-    private deserialize;
-}