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

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

@@ -6,36 +6,11 @@ export interface DescribeLoadBalancerPolicyTypesCommandInput extends DescribeLoa
 }
 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

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

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

@@ -6,32 +6,11 @@ export interface DetachLoadBalancerFromSubnetsCommandInput extends DetachLoadBal
 }
 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

@@ -6,37 +6,11 @@ export interface DisableAvailabilityZonesForLoadBalancerCommandInput extends Rem
 }
 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;

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

@@ -6,34 +6,11 @@ export interface EnableAvailabilityZonesForLoadBalancerCommandInput extends AddA
 }
 export interface EnableAvailabilityZonesForLoadBalancerCommandOutput extends AddAvailabilityZonesOutput, __MetadataBearer {
 }
-/**
- * <p>Adds the specified Availability Zones to 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>AttachLoadBalancerToSubnets</a>.</p>
- *         <p>The load balancer evenly distributes requests across all its registered Availability Zones
- *             that contain instances. 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, EnableAvailabilityZonesForLoadBalancerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, EnableAvailabilityZonesForLoadBalancerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new EnableAvailabilityZonesForLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link EnableAvailabilityZonesForLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link EnableAvailabilityZonesForLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class EnableAvailabilityZonesForLoadBalancerCommand extends $Command<EnableAvailabilityZonesForLoadBalancerCommandInput, EnableAvailabilityZonesForLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: EnableAvailabilityZonesForLoadBalancerCommandInput;
     constructor(input: EnableAvailabilityZonesForLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableAvailabilityZonesForLoadBalancerCommandInput, EnableAvailabilityZonesForLoadBalancerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,55 +6,11 @@ export interface ModifyLoadBalancerAttributesCommandInput extends ModifyLoadBala
 }
 export interface ModifyLoadBalancerAttributesCommandOutput extends ModifyLoadBalancerAttributesOutput, __MetadataBearer {
 }
-/**
- * <p>Modifies the attributes of the specified load balancer.</p>
- *         <p>You can modify the load balancer attributes, such as <code>AccessLogs</code>, <code>ConnectionDraining</code>, and
- *             <code>CrossZoneLoadBalancing</code> by either enabling or disabling them. Or, you can modify the load balancer attribute
- *             <code>ConnectionSettings</code> by specifying an idle connection timeout value for your load balancer.</p>
- *         <p>For more information, see the following in the <i>Classic Load Balancers Guide</i>:</p>
- *         <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-crosszone-lb.html">Cross-Zone Load Balancing</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-conn-drain.html">Connection Draining</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html">Access Logs</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-idle-timeout.html">Idle Connection Timeout</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingClient, ModifyLoadBalancerAttributesCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, ModifyLoadBalancerAttributesCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new ModifyLoadBalancerAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyLoadBalancerAttributesCommandInput} for command's `input` shape.
- * @see {@link ModifyLoadBalancerAttributesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyLoadBalancerAttributesCommand extends $Command<ModifyLoadBalancerAttributesCommandInput, ModifyLoadBalancerAttributesCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: ModifyLoadBalancerAttributesCommandInput;
     constructor(input: ModifyLoadBalancerAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyLoadBalancerAttributesCommandInput, ModifyLoadBalancerAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,47 +6,11 @@ export interface RegisterInstancesWithLoadBalancerCommandInput extends RegisterE
 }
 export interface RegisterInstancesWithLoadBalancerCommandOutput extends RegisterEndPointsOutput, __MetadataBearer {
 }
-/**
- * <p>Adds the specified instances to the specified load balancer.</p>
- *
- *         <p>The instance must be a running instance in the same network as the load balancer (EC2-Classic or the same VPC). If you have EC2-Classic instances and a load balancer in a VPC with ClassicLink enabled, you can link the EC2-Classic instances to that VPC and then register the linked EC2-Classic instances with the load balancer in the VPC.</p>
- *
- *         <p>Note that <code>RegisterInstanceWithLoadBalancer</code> completes when the request has been registered.
- *          Instance registration takes a little time to complete. To check the state of the registered instances, use
- *          <a>DescribeLoadBalancers</a> or <a>DescribeInstanceHealth</a>.</p>
- *
- *         <p>After the instance is registered, it starts receiving traffic
- *          and requests from the load balancer. Any instance that is not
- *          in one of the Availability Zones registered for the load balancer
- *          is moved to the <code>OutOfService</code> state. If an Availability Zone
- *          is added to the load balancer later, any instances registered with the
- *          load balancer move to the <code>InService</code> state.</p>
- *
- *         <p>To deregister instances from a load balancer, use <a>DeregisterInstancesFromLoadBalancer</a>.</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, RegisterInstancesWithLoadBalancerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, RegisterInstancesWithLoadBalancerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new RegisterInstancesWithLoadBalancerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RegisterInstancesWithLoadBalancerCommandInput} for command's `input` shape.
- * @see {@link RegisterInstancesWithLoadBalancerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RegisterInstancesWithLoadBalancerCommand extends $Command<RegisterInstancesWithLoadBalancerCommandInput, RegisterInstancesWithLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: RegisterInstancesWithLoadBalancerCommandInput;
     constructor(input: RegisterInstancesWithLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterInstancesWithLoadBalancerCommandInput, RegisterInstancesWithLoadBalancerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface RemoveTagsCommandInput extends RemoveTagsInput {
 }
 export interface RemoveTagsCommandOutput extends RemoveTagsOutput, __MetadataBearer {
 }
-/**
- * <p>Removes one or more tags 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, RemoveTagsCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, RemoveTagsCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new RemoveTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemoveTagsCommandInput} for command's `input` shape.
- * @see {@link RemoveTagsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemoveTagsCommand extends $Command<RemoveTagsCommandInput, RemoveTagsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: RemoveTagsCommandInput;
     constructor(input: RemoveTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTagsCommandInput, RemoveTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface SetLoadBalancerListenerSSLCertificateCommandInput extends SetLo
 }
 export interface SetLoadBalancerListenerSSLCertificateCommandOutput extends SetLoadBalancerListenerSSLCertificateOutput, __MetadataBearer {
 }
-/**
- * <p>Sets the certificate that terminates the specified listener's SSL connections. The specified certificate replaces any prior certificate that was used on the same load balancer and port.</p>
- *
- *         <p>For more information about updating your SSL certificate, see
- *             <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-update-ssl-cert.html">Replace the SSL Certificate 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, SetLoadBalancerListenerSSLCertificateCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, SetLoadBalancerListenerSSLCertificateCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new SetLoadBalancerListenerSSLCertificateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetLoadBalancerListenerSSLCertificateCommandInput} for command's `input` shape.
- * @see {@link SetLoadBalancerListenerSSLCertificateCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetLoadBalancerListenerSSLCertificateCommand extends $Command<SetLoadBalancerListenerSSLCertificateCommandInput, SetLoadBalancerListenerSSLCertificateCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: SetLoadBalancerListenerSSLCertificateCommandInput;
     constructor(input: SetLoadBalancerListenerSSLCertificateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetLoadBalancerListenerSSLCertificateCommandInput, SetLoadBalancerListenerSSLCertificateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,39 +6,11 @@ export interface SetLoadBalancerPoliciesForBackendServerCommandInput extends Set
 }
 export interface SetLoadBalancerPoliciesForBackendServerCommandOutput extends SetLoadBalancerPoliciesForBackendServerOutput, __MetadataBearer {
 }
-/**
- * <p>Replaces the set of policies associated with the specified port on which the EC2 instance is listening with a new set of policies.
- *             At this time, only the back-end server authentication policy type can be applied to the instance ports; this policy type is composed of multiple public key policies.</p>
- *         <p>Each time you use <code>SetLoadBalancerPoliciesForBackendServer</code> to enable the policies,
- *             use the <code>PolicyNames</code> parameter to list the policies that you want to enable.</p>
- *         <p>You can use <a>DescribeLoadBalancers</a> or <a>DescribeLoadBalancerPolicies</a> to verify that the policy
- *             is associated with the EC2 instance.</p>
- *
- *         <p>For more information about enabling back-end instance authentication, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-create-https-ssl-load-balancer.html#configure_backendauth_clt">Configure Back-end Instance Authentication</a>
- *             in the <i>Classic Load Balancers Guide</i>. For more information about Proxy Protocol, see
- *             <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-proxy-protocol.html">Configure Proxy Protocol Support</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, SetLoadBalancerPoliciesForBackendServerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, SetLoadBalancerPoliciesForBackendServerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new SetLoadBalancerPoliciesForBackendServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetLoadBalancerPoliciesForBackendServerCommandInput} for command's `input` shape.
- * @see {@link SetLoadBalancerPoliciesForBackendServerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetLoadBalancerPoliciesForBackendServerCommand extends $Command<SetLoadBalancerPoliciesForBackendServerCommandInput, SetLoadBalancerPoliciesForBackendServerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: SetLoadBalancerPoliciesForBackendServerCommandInput;
     constructor(input: SetLoadBalancerPoliciesForBackendServerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetLoadBalancerPoliciesForBackendServerCommandInput, SetLoadBalancerPoliciesForBackendServerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface SetLoadBalancerPoliciesOfListenerCommandInput extends SetLoadBa
 }
 export interface SetLoadBalancerPoliciesOfListenerCommandOutput extends SetLoadBalancerPoliciesOfListenerOutput, __MetadataBearer {
 }
-/**
- * <p>Replaces the current set of policies for the specified load balancer port with the specified set of policies.</p>
- *         <p>To enable back-end server authentication, use <a>SetLoadBalancerPoliciesForBackendServer</a>.</p>
- *         <p>For more information about setting policies, see
- *             <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/ssl-config-update.html">Update the SSL Negotiation Configuration</a>,
- *             <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-sticky-sessions.html#enable-sticky-sessions-duration">Duration-Based Session Stickiness</a>, and
- *             <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, SetLoadBalancerPoliciesOfListenerCommand } from "@aws-sdk/client-elastic-load-balancing"; // ES Modules import
- * // const { ElasticLoadBalancingClient, SetLoadBalancerPoliciesOfListenerCommand } = require("@aws-sdk/client-elastic-load-balancing"); // CommonJS import
- * const client = new ElasticLoadBalancingClient(config);
- * const command = new SetLoadBalancerPoliciesOfListenerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetLoadBalancerPoliciesOfListenerCommandInput} for command's `input` shape.
- * @see {@link SetLoadBalancerPoliciesOfListenerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetLoadBalancerPoliciesOfListenerCommand extends $Command<SetLoadBalancerPoliciesOfListenerCommandInput, SetLoadBalancerPoliciesOfListenerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
     readonly input: SetLoadBalancerPoliciesOfListenerCommandInput;
     constructor(input: SetLoadBalancerPoliciesOfListenerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetLoadBalancerPoliciesOfListenerCommandInput, SetLoadBalancerPoliciesOfListenerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,29 @@
+export * from "./AddTagsCommand";
+export * from "./ApplySecurityGroupsToLoadBalancerCommand";
+export * from "./AttachLoadBalancerToSubnetsCommand";
+export * from "./ConfigureHealthCheckCommand";
+export * from "./CreateAppCookieStickinessPolicyCommand";
+export * from "./CreateLBCookieStickinessPolicyCommand";
+export * from "./CreateLoadBalancerCommand";
+export * from "./CreateLoadBalancerListenersCommand";
+export * from "./CreateLoadBalancerPolicyCommand";
+export * from "./DeleteLoadBalancerCommand";
+export * from "./DeleteLoadBalancerListenersCommand";
+export * from "./DeleteLoadBalancerPolicyCommand";
+export * from "./DeregisterInstancesFromLoadBalancerCommand";
+export * from "./DescribeAccountLimitsCommand";
+export * from "./DescribeInstanceHealthCommand";
+export * from "./DescribeLoadBalancerAttributesCommand";
+export * from "./DescribeLoadBalancerPoliciesCommand";
+export * from "./DescribeLoadBalancerPolicyTypesCommand";
+export * from "./DescribeLoadBalancersCommand";
+export * from "./DescribeTagsCommand";
+export * from "./DetachLoadBalancerFromSubnetsCommand";
+export * from "./DisableAvailabilityZonesForLoadBalancerCommand";
+export * from "./EnableAvailabilityZonesForLoadBalancerCommand";
+export * from "./ModifyLoadBalancerAttributesCommand";
+export * from "./RegisterInstancesWithLoadBalancerCommand";
+export * from "./RemoveTagsCommand";
+export * from "./SetLoadBalancerListenerSSLCertificateCommand";
+export * from "./SetLoadBalancerPoliciesForBackendServerCommand";
+export * from "./SetLoadBalancerPoliciesOfListenerCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,35 +1,6 @@
-export * from "./ElasticLoadBalancingClient";
 export * from "./ElasticLoadBalancing";
-export * from "./commands/AddTagsCommand";
-export * from "./commands/ApplySecurityGroupsToLoadBalancerCommand";
-export * from "./commands/AttachLoadBalancerToSubnetsCommand";
-export * from "./commands/ConfigureHealthCheckCommand";
-export * from "./commands/CreateAppCookieStickinessPolicyCommand";
-export * from "./commands/CreateLBCookieStickinessPolicyCommand";
-export * from "./commands/CreateLoadBalancerCommand";
-export * from "./commands/CreateLoadBalancerListenersCommand";
-export * from "./commands/CreateLoadBalancerPolicyCommand";
-export * from "./commands/DeleteLoadBalancerCommand";
-export * from "./commands/DeleteLoadBalancerListenersCommand";
-export * from "./commands/DeleteLoadBalancerPolicyCommand";
-export * from "./commands/DeregisterInstancesFromLoadBalancerCommand";
-export * from "./commands/DescribeAccountLimitsCommand";
-export * from "./commands/DescribeInstanceHealthCommand";
-export * from "./waiters/waitForAnyInstanceInService";
-export * from "./commands/DescribeLoadBalancerAttributesCommand";
-export * from "./commands/DescribeLoadBalancerPoliciesCommand";
-export * from "./commands/DescribeLoadBalancerPolicyTypesCommand";
-export * from "./commands/DescribeLoadBalancersCommand";
-export * from "./pagination/DescribeLoadBalancersPaginator";
-export * from "./commands/DescribeTagsCommand";
-export * from "./commands/DetachLoadBalancerFromSubnetsCommand";
-export * from "./commands/DisableAvailabilityZonesForLoadBalancerCommand";
-export * from "./commands/EnableAvailabilityZonesForLoadBalancerCommand";
-export * from "./commands/ModifyLoadBalancerAttributesCommand";
-export * from "./commands/RegisterInstancesWithLoadBalancerCommand";
-export * from "./commands/RemoveTagsCommand";
-export * from "./commands/SetLoadBalancerListenerSSLCertificateCommand";
-export * from "./commands/SetLoadBalancerPoliciesForBackendServerCommand";
-export * from "./commands/SetLoadBalancerPoliciesOfListenerCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./ElasticLoadBalancingClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export * from "./waiters";