@aws-sdk/client-elastic-load-balancing 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/AddTagsCommand.d.ts

@@ -6,35 +6,11 @@ export interface AddTagsCommandInput extends AddTagsInput {
 }
 export interface AddTagsCommandOutput extends AddTagsOutput, __MetadataBearer {
 }
-/**
- * <p>Adds the specified tags to the specified load balancer. Each load balancer can have a maximum of 10 tags.</p>
- *
- *         <p>Each tag consists of a key and an optional value. If a tag with the same key is already associated
- *             with the load balancer, <code>AddTags</code> updates its value.</p>
- *
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/add-remove-tags.html">Tag 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, AddTagsCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, AddTagsCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new AddTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AddTagsCommandInput} for command's `input` shape.
- * @see {@link AddTagsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AddTagsCommand extends $Command<AddTagsCommandInput, AddTagsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: AddTagsCommandInput;
     constructor(input: AddTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddTagsCommandInput, AddTagsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ApplySecurityGroupsToLoadBalancerCommand.d.ts

@@ -6,31 +6,11 @@ export interface ApplySecurityGroupsToLoadBalancerCommandInput extends ApplySecu
 }
 export interface ApplySecurityGroupsToLoadBalancerCommandOutput extends ApplySecurityGroupsToLoadBalancerOutput, __MetadataBearer {
 }
-/**
- * <p>Associates one or more security groups with your load balancer in a virtual private cloud (VPC). The specified security groups override the previously associated security groups.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-security-groups.html#elb-vpc-security-groups">Security Groups for Load Balancers in a VPC</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, ApplySecurityGroupsToLoadBalancerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, ApplySecurityGroupsToLoadBalancerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new ApplySecurityGroupsToLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ApplySecurityGroupsToLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link ApplySecurityGroupsToLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ApplySecurityGroupsToLoadBalancerCommand extends $Command<ApplySecurityGroupsToLoadBalancerCommandInput, ApplySecurityGroupsToLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: ApplySecurityGroupsToLoadBalancerCommandInput;
     constructor(input: ApplySecurityGroupsToLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ApplySecurityGroupsToLoadBalancerCommandInput, ApplySecurityGroupsToLoadBalancerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/AttachLoadBalancerToSubnetsCommand.d.ts

@@ -6,32 +6,11 @@ export interface AttachLoadBalancerToSubnetsCommandInput extends AttachLoadBalan
 }
 export interface AttachLoadBalancerToSubnetsCommandOutput extends AttachLoadBalancerToSubnetsOutput, __MetadataBearer {
 }
-/**
- * <p>Adds one or more subnets to the set of configured subnets for the specified load balancer.</p>
- *         <p>The load balancer evenly distributes requests across all registered subnets.
- *             For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-manage-subnets.html">Add or Remove Subnets for Your Load Balancer in a VPC</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, AttachLoadBalancerToSubnetsCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, AttachLoadBalancerToSubnetsCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new AttachLoadBalancerToSubnetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AttachLoadBalancerToSubnetsCommandInput} for command's `input` shape.
- * @see {@link AttachLoadBalancerToSubnetsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AttachLoadBalancerToSubnetsCommand extends $Command<AttachLoadBalancerToSubnetsCommandInput, AttachLoadBalancerToSubnetsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: AttachLoadBalancerToSubnetsCommandInput;
     constructor(input: AttachLoadBalancerToSubnetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachLoadBalancerToSubnetsCommandInput, AttachLoadBalancerToSubnetsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ConfigureHealthCheckCommand.d.ts

@@ -6,31 +6,11 @@ export interface ConfigureHealthCheckCommandInput extends ConfigureHealthCheckIn
 }
 export interface ConfigureHealthCheckCommandOutput extends ConfigureHealthCheckOutput, __MetadataBearer {
 }
-/**
- * <p>Specifies the health check settings to use when evaluating the health state of your EC2 instances.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-healthchecks.html">Configure Health Checks for Your 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, ConfigureHealthCheckCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, ConfigureHealthCheckCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new ConfigureHealthCheckCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ConfigureHealthCheckCommandInput} for command's `input` shape.
- * @see {@link ConfigureHealthCheckCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ConfigureHealthCheckCommand extends $Command<ConfigureHealthCheckCommandInput, ConfigureHealthCheckCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: ConfigureHealthCheckCommandInput;
     constructor(input: ConfigureHealthCheckCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfigureHealthCheckCommandInput, ConfigureHealthCheckCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateAppCookieStickinessPolicyCommand.d.ts

@@ -6,37 +6,11 @@ export interface CreateAppCookieStickinessPolicyCommandInput extends CreateAppCo
 }
 export interface CreateAppCookieStickinessPolicyCommandOutput extends CreateAppCookieStickinessPolicyOutput, __MetadataBearer {
 }
-/**
- * <p>Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners.</p>
- *         <p>This policy is similar to the policy created by <a>CreateLBCookieStickinessPolicy</a>,
- *             except that the lifetime of the special Elastic Load Balancing cookie, <code>AWSELB</code>,
- *             follows the lifetime of the application-generated cookie specified in the policy configuration.
- *             The load balancer only inserts a new stickiness cookie when the application response
- *             includes a new application cookie.</p>
- *         <p>If the application cookie is explicitly removed or expires, the session stops being sticky until a new application cookie is issued.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-application">Application-Controlled 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, CreateAppCookieStickinessPolicyCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, CreateAppCookieStickinessPolicyCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new CreateAppCookieStickinessPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAppCookieStickinessPolicyCommandInput} for command's `input` shape.
- * @see {@link CreateAppCookieStickinessPolicyCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateAppCookieStickinessPolicyCommand extends $Command<CreateAppCookieStickinessPolicyCommandInput, CreateAppCookieStickinessPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: CreateAppCookieStickinessPolicyCommandInput;
     constructor(input: CreateAppCookieStickinessPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAppCookieStickinessPolicyCommandInput, CreateAppCookieStickinessPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface CreateLBCookieStickinessPolicyCommandInput extends CreateLBCook
 }
 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

@@ -6,42 +6,11 @@ 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

@@ -6,31 +6,11 @@ export interface CreateLoadBalancerListenersCommandInput extends CreateLoadBalan
 }
 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

@@ -6,30 +6,11 @@ export interface CreateLoadBalancerPolicyCommandInput extends CreateLoadBalancer
 }
 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

@@ -6,32 +6,11 @@ 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/DeleteLoadBalancerListenersCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteLoadBalancerListenersCommandInput extends DeleteLoadBalan
 }
 export interface DeleteLoadBalancerListenersCommandOutput extends DeleteLoadBalancerListenerOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified listeners from the specified load balancer.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DeleteLoadBalancerListenersCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DeleteLoadBalancerListenersCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DeleteLoadBalancerListenersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLoadBalancerListenersCommandInput} for command's `input` shape.
- * @see {@link DeleteLoadBalancerListenersCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLoadBalancerListenersCommand extends $Command<DeleteLoadBalancerListenersCommandInput, DeleteLoadBalancerListenersCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: DeleteLoadBalancerListenersCommandInput;
     constructor(input: DeleteLoadBalancerListenersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoadBalancerListenersCommandInput, DeleteLoadBalancerListenersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteLoadBalancerPolicyCommandInput extends DeleteLoadBalancer
 }
 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

@@ -6,34 +6,11 @@ export interface DeregisterInstancesFromLoadBalancerCommandInput extends Deregis
 }
 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

@@ -6,31 +6,11 @@ export interface DescribeAccountLimitsCommandInput extends DescribeAccountLimits
 }
 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

@@ -6,29 +6,11 @@ export interface DescribeInstanceHealthCommandInput extends DescribeEndPointStat
 }
 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/DescribeLoadBalancerAttributesCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeLoadBalancerAttributesCommandInput extends DescribeLoad
 }
 export interface DescribeLoadBalancerAttributesCommandOutput extends DescribeLoadBalancerAttributesOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the attributes for the specified load balancer.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, DescribeLoadBalancerAttributesCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, DescribeLoadBalancerAttributesCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new DescribeLoadBalancerAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLoadBalancerAttributesCommandInput} for command's `input` shape.
- * @see {@link DescribeLoadBalancerAttributesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLoadBalancerAttributesCommand extends $Command<DescribeLoadBalancerAttributesCommandInput, DescribeLoadBalancerAttributesCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: DescribeLoadBalancerAttributesCommandInput;
     constructor(input: DescribeLoadBalancerAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancerAttributesCommandInput, DescribeLoadBalancerAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeLoadBalancerPoliciesCommandInput extends DescribeLoadBa
 }
 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;