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

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

@@ -6,30 +6,11 @@ export interface DeregisterTargetsCommandInput extends DeregisterTargetsInput {
 }
 export interface DeregisterTargetsCommandOutput extends DeregisterTargetsOutput, __MetadataBearer {
 }
-/**
- * <p>Deregisters the specified targets from the specified target group. After the targets are
- *       deregistered, they no longer receive traffic from the load balancer.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DeregisterTargetsCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DeregisterTargetsCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DeregisterTargetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterTargetsCommandInput} for command's `input` shape.
- * @see {@link DeregisterTargetsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterTargetsCommand extends $Command<DeregisterTargetsCommandInput, DeregisterTargetsCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DeregisterTargetsCommandInput;
     constructor(input: DeregisterTargetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterTargetsCommandInput, DeregisterTargetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,51 +6,11 @@ export interface DescribeAccountLimitsCommandInput extends DescribeAccountLimits
 }
 export interface DescribeAccountLimitsCommandOutput extends DescribeAccountLimitsOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the current Elastic Load Balancing resource limits for your Amazon Web Services
- *       account.</p>
- *          <p>For more information, see the following:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html">Quotas for your
- *             Application Load Balancers</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-limits.html">Quotas for your
- *             Network Load Balancers</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/quotas-limits.html">Quotas for your Gateway
- *             Load Balancers</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeAccountLimitsCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeAccountLimitsCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(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 ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAccountLimitsCommand extends $Command<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeAccountLimitsCommandInput;
     constructor(input: DescribeAccountLimitsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DescribeListenerCertificatesCommandInput extends DescribeListen
 }
 export interface DescribeListenerCertificatesCommandOutput extends DescribeListenerCertificatesOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the default certificate and the certificate list for the specified HTTPS or TLS
- *       listener.</p>
- *          <p>If the default certificate is also in the certificate list, it appears twice in the
- *       results (once with <code>IsDefault</code> set to true and once with <code>IsDefault</code> set
- *       to false).</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#https-listener-certificates">SSL certificates</a> in the <i>Application Load Balancers Guide</i> or
- *         <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#tls-listener-certificate">Server certificates</a> in the <i>Network Load Balancers
- *       Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeListenerCertificatesCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeListenerCertificatesCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DescribeListenerCertificatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeListenerCertificatesCommandInput} for command's `input` shape.
- * @see {@link DescribeListenerCertificatesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeListenerCertificatesCommand extends $Command<DescribeListenerCertificatesCommandInput, DescribeListenerCertificatesCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeListenerCertificatesCommandInput;
     constructor(input: DescribeListenerCertificatesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeListenerCertificatesCommandInput, DescribeListenerCertificatesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeListenersCommandInput extends DescribeListenersInput {
 }
 export interface DescribeListenersCommandOutput extends DescribeListenersOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the specified listeners or the listeners for the specified Application Load
- *       Balancer, Network Load Balancer, or Gateway Load Balancer. You must specify either a load
- *       balancer or one or more listeners.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeListenersCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeListenersCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DescribeListenersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeListenersCommandInput} for command's `input` shape.
- * @see {@link DescribeListenersCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeListenersCommand extends $Command<DescribeListenersCommandInput, DescribeListenersCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeListenersCommandInput;
     constructor(input: DescribeListenersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeListenersCommandInput, DescribeListenersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,52 +6,11 @@ export interface DescribeLoadBalancerAttributesCommandInput extends DescribeLoad
 }
 export interface DescribeLoadBalancerAttributesCommandOutput extends DescribeLoadBalancerAttributesOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the attributes for the specified Application Load Balancer, Network Load
- *       Balancer, or Gateway Load Balancer.</p>
- *
- *          <p>For more information, see the following:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html#load-balancer-attributes">Load balancer attributes</a> in the <i>Application Load Balancers
- *             Guide</i>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html#load-balancer-attributes">Load balancer attributes</a> in the <i>Network Load Balancers
- *             Guide</i>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/gateway-load-balancers.html#load-balancer-attributes">Load balancer attributes</a> in the <i>Gateway Load Balancers
- *             Guide</i>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeLoadBalancerAttributesCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeLoadBalancerAttributesCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(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 ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLoadBalancerAttributesCommand extends $Command<DescribeLoadBalancerAttributesCommandInput, DescribeLoadBalancerAttributesCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeLoadBalancerAttributesCommandInput;
     constructor(input: DescribeLoadBalancerAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancerAttributesCommandInput, DescribeLoadBalancerAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeLoadBalancersCommandInput extends DescribeLoadBalancers
 }
 export interface DescribeLoadBalancersCommandOutput extends DescribeLoadBalancersOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the specified load balancers or all of your load balancers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeLoadBalancersCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeLoadBalancersCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(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 ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLoadBalancersCommand extends $Command<DescribeLoadBalancersCommandInput, DescribeLoadBalancersCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeLoadBalancersCommandInput;
     constructor(input: DescribeLoadBalancersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancersCommandInput, DescribeLoadBalancersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeRulesCommandInput extends DescribeRulesInput {
 }
 export interface DescribeRulesCommandOutput extends DescribeRulesOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the specified rules or the rules for the specified listener. You must specify
- *       either a listener or one or more rules.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeRulesCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeRulesCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DescribeRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRulesCommandInput} for command's `input` shape.
- * @see {@link DescribeRulesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeRulesCommand extends $Command<DescribeRulesCommandInput, DescribeRulesCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeRulesCommandInput;
     constructor(input: DescribeRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRulesCommandInput, DescribeRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeSSLPoliciesCommandInput extends DescribeSSLPoliciesInpu
 }
 export interface DescribeSSLPoliciesCommandOutput extends DescribeSSLPoliciesOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the specified policies or all policies used for SSL negotiation.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies">Security policies</a> in the <i>Application Load Balancers Guide</i> or
- *         <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#describe-ssl-policies">Security policies</a> in the <i>Network Load Balancers Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeSSLPoliciesCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeSSLPoliciesCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DescribeSSLPoliciesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSSLPoliciesCommandInput} for command's `input` shape.
- * @see {@link DescribeSSLPoliciesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSSLPoliciesCommand extends $Command<DescribeSSLPoliciesCommandInput, DescribeSSLPoliciesCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeSSLPoliciesCommandInput;
     constructor(input: DescribeSSLPoliciesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSSLPoliciesCommandInput, DescribeSSLPoliciesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeTagsCommandInput extends DescribeTagsInput {
 }
 export interface DescribeTagsCommandOutput extends DescribeTagsOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the tags for the specified Elastic Load Balancing resources. You can describe
- *       the tags for one or more Application Load Balancers, Network Load Balancers, Gateway Load
- *       Balancers, target groups, listeners, or rules.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeTagsCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeTagsCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(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 ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTagsCommand extends $Command<DescribeTagsCommandInput, DescribeTagsCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeTagsCommandInput;
     constructor(input: DescribeTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTagsCommandInput, DescribeTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,50 +6,11 @@ export interface DescribeTargetGroupAttributesCommandInput extends DescribeTarge
 }
 export interface DescribeTargetGroupAttributesCommandOutput extends DescribeTargetGroupAttributesOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the attributes for the specified target group.</p>
- *          <p>For more information, see the following:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes">Target group attributes</a> in the <i>Application Load Balancers
- *             Guide</i>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-group-attributes">Target group attributes</a> in the <i>Network Load Balancers
- *             Guide</i>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/target-groups.html#target-group-attributes">Target group attributes</a> in the <i>Gateway Load Balancers
- *             Guide</i>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeTargetGroupAttributesCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeTargetGroupAttributesCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DescribeTargetGroupAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTargetGroupAttributesCommandInput} for command's `input` shape.
- * @see {@link DescribeTargetGroupAttributesCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTargetGroupAttributesCommand extends $Command<DescribeTargetGroupAttributesCommandInput, DescribeTargetGroupAttributesCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeTargetGroupAttributesCommandInput;
     constructor(input: DescribeTargetGroupAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTargetGroupAttributesCommandInput, DescribeTargetGroupAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeTargetGroupsCommandInput extends DescribeTargetGroupsIn
 }
 export interface DescribeTargetGroupsCommandOutput extends DescribeTargetGroupsOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the specified target groups or all of your target groups. By default, all target
- *       groups are described. Alternatively, you can specify one of the following to filter the
- *       results: the ARN of the load balancer, the names of one or more target groups, or the ARNs of
- *       one or more target groups.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeTargetGroupsCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeTargetGroupsCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DescribeTargetGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTargetGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeTargetGroupsCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTargetGroupsCommand extends $Command<DescribeTargetGroupsCommandInput, DescribeTargetGroupsCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeTargetGroupsCommandInput;
     constructor(input: DescribeTargetGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTargetGroupsCommandInput, DescribeTargetGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeTargetHealthCommandInput extends DescribeTargetHealthIn
 }
 export interface DescribeTargetHealthCommandOutput extends DescribeTargetHealthOutput, __MetadataBearer {
 }
-/**
- * <p>Describes the health of the specified targets or all of your targets.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, DescribeTargetHealthCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, DescribeTargetHealthCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new DescribeTargetHealthCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTargetHealthCommandInput} for command's `input` shape.
- * @see {@link DescribeTargetHealthCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTargetHealthCommand extends $Command<DescribeTargetHealthCommandInput, DescribeTargetHealthCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: DescribeTargetHealthCommandInput;
     constructor(input: DescribeTargetHealthCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTargetHealthCommandInput, DescribeTargetHealthCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface ModifyListenerCommandInput extends ModifyListenerInput {
 }
 export interface ModifyListenerCommandOutput extends ModifyListenerOutput, __MetadataBearer {
 }
-/**
- * <p>Replaces the specified properties of the specified listener. Any properties that you do
- *       not specify remain unchanged.</p>
- *          <p>Changing the protocol from HTTPS to HTTP, or from TLS to TCP, removes the security policy
- *       and default certificate properties. If you change the protocol from HTTP to HTTPS, or from TCP
- *       to TLS, you must add the security policy and default certificate properties.</p>
- *          <p>To add an item to a list, remove an item from a list, or update an item in a list, you
- *       must provide the entire list. For example, to add an action, specify a list with the current
- *       actions plus the new action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, ModifyListenerCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, ModifyListenerCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new ModifyListenerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyListenerCommandInput} for command's `input` shape.
- * @see {@link ModifyListenerCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyListenerCommand extends $Command<ModifyListenerCommandInput, ModifyListenerCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: ModifyListenerCommandInput;
     constructor(input: ModifyListenerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyListenerCommandInput, ModifyListenerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ModifyLoadBalancerAttributesCommandInput extends ModifyLoadBala
 }
 export interface ModifyLoadBalancerAttributesCommandOutput extends ModifyLoadBalancerAttributesOutput, __MetadataBearer {
 }
-/**
- * <p>Modifies the specified attributes of the specified Application Load Balancer, Network Load
- *       Balancer, or Gateway Load Balancer.</p>
- *          <p>If any of the specified attributes can't be modified as requested, the call fails. Any
- *       existing attributes that you do not modify retain their current values.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, ModifyLoadBalancerAttributesCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, ModifyLoadBalancerAttributesCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(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 ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyLoadBalancerAttributesCommand extends $Command<ModifyLoadBalancerAttributesCommandInput, ModifyLoadBalancerAttributesCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: ModifyLoadBalancerAttributesCommandInput;
     constructor(input: ModifyLoadBalancerAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyLoadBalancerAttributesCommandInput, ModifyLoadBalancerAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ModifyRuleCommandInput extends ModifyRuleInput {
 }
 export interface ModifyRuleCommandOutput extends ModifyRuleOutput, __MetadataBearer {
 }
-/**
- * <p>Replaces the specified properties of the specified rule. Any properties that you do not
- *       specify are unchanged.</p>
- *          <p>To add an item to a list, remove an item from a list, or update an item in a list, you
- *       must provide the entire list. For example, to add an action, specify a list with the current
- *       actions plus the new action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticLoadBalancingV2Client, ModifyRuleCommand } from "@aws-sdk/client-elastic-load-balancing-v2"; // ES Modules import
- * // const { ElasticLoadBalancingV2Client, ModifyRuleCommand } = require("@aws-sdk/client-elastic-load-balancing-v2"); // CommonJS import
- * const client = new ElasticLoadBalancingV2Client(config);
- * const command = new ModifyRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyRuleCommandInput} for command's `input` shape.
- * @see {@link ModifyRuleCommandOutput} for command's `response` shape.
- * @see {@link ElasticLoadBalancingV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyRuleCommand extends $Command<ModifyRuleCommandInput, ModifyRuleCommandOutput, ElasticLoadBalancingV2ClientResolvedConfig> {
     readonly input: ModifyRuleCommandInput;
     constructor(input: ModifyRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyRuleCommandInput, ModifyRuleCommandOutput>;
     private serialize;
     private deserialize;

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

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