@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,31 +6,11 @@ export interface DeregisterInstanceEventNotificationAttributesCommandInput exten
 }
 export interface DeregisterInstanceEventNotificationAttributesCommandOutput extends DeregisterInstanceEventNotificationAttributesResult, __MetadataBearer {
 }
-/**
- * <p>c</p>
- *    	     <p>Deregisters tag keys to prevent tags that have the specified tag keys from being included
- * 			in scheduled event notifications for resources in the Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeregisterInstanceEventNotificationAttributesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeregisterInstanceEventNotificationAttributesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeregisterInstanceEventNotificationAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterInstanceEventNotificationAttributesCommandInput} for command's `input` shape.
- * @see {@link DeregisterInstanceEventNotificationAttributesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterInstanceEventNotificationAttributesCommand extends $Command<DeregisterInstanceEventNotificationAttributesCommandInput, DeregisterInstanceEventNotificationAttributesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeregisterInstanceEventNotificationAttributesCommandInput;
     constructor(input: DeregisterInstanceEventNotificationAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterInstanceEventNotificationAttributesCommandInput, DeregisterInstanceEventNotificationAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeregisterTransitGatewayMulticastGroupMembersCommandInput exten
 }
 export interface DeregisterTransitGatewayMulticastGroupMembersCommandOutput extends DeregisterTransitGatewayMulticastGroupMembersResult, __MetadataBearer {
 }
-/**
- * <p>Deregisters the specified members (network interfaces) from the  transit gateway multicast group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeregisterTransitGatewayMulticastGroupMembersCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeregisterTransitGatewayMulticastGroupMembersCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeregisterTransitGatewayMulticastGroupMembersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterTransitGatewayMulticastGroupMembersCommandInput} for command's `input` shape.
- * @see {@link DeregisterTransitGatewayMulticastGroupMembersCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterTransitGatewayMulticastGroupMembersCommand extends $Command<DeregisterTransitGatewayMulticastGroupMembersCommandInput, DeregisterTransitGatewayMulticastGroupMembersCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeregisterTransitGatewayMulticastGroupMembersCommandInput;
     constructor(input: DeregisterTransitGatewayMulticastGroupMembersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterTransitGatewayMulticastGroupMembersCommandInput, DeregisterTransitGatewayMulticastGroupMembersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeregisterTransitGatewayMulticastGroupSourcesCommandInput exten
 }
 export interface DeregisterTransitGatewayMulticastGroupSourcesCommandOutput extends DeregisterTransitGatewayMulticastGroupSourcesResult, __MetadataBearer {
 }
-/**
- * <p>Deregisters the specified sources (network interfaces) from the  transit gateway multicast group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DeregisterTransitGatewayMulticastGroupSourcesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DeregisterTransitGatewayMulticastGroupSourcesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DeregisterTransitGatewayMulticastGroupSourcesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterTransitGatewayMulticastGroupSourcesCommandInput} for command's `input` shape.
- * @see {@link DeregisterTransitGatewayMulticastGroupSourcesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterTransitGatewayMulticastGroupSourcesCommand extends $Command<DeregisterTransitGatewayMulticastGroupSourcesCommandInput, DeregisterTransitGatewayMulticastGroupSourcesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DeregisterTransitGatewayMulticastGroupSourcesCommandInput;
     constructor(input: DeregisterTransitGatewayMulticastGroupSourcesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterTransitGatewayMulticastGroupSourcesCommandInput, DeregisterTransitGatewayMulticastGroupSourcesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,63 +6,11 @@ export interface DescribeAccountAttributesCommandInput extends DescribeAccountAt
 }
 export interface DescribeAccountAttributesCommandOutput extends DescribeAccountAttributesResult, __MetadataBearer {
 }
-/**
- * <p>Describes attributes of your AWS account. The following are the supported account attributes:</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <code>supported-platforms</code>: Indicates whether your account can launch instances
- *           into EC2-Classic and EC2-VPC, or only into EC2-VPC.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>default-vpc</code>: The ID of the default VPC for your account, or
- *             <code>none</code>.</p>
- *             </li>
- *             <li>
- *                <p>
- *                     <code>max-instances</code>: This attribute is no longer supported. The returned
- *                     value does not reflect your actual vCPU limit for running On-Demand Instances.
- *                     For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-on-demand-instances.html#ec2-on-demand-instances-limits">On-Demand Instance Limits</a> in the
- *                         <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>vpc-max-security-groups-per-interface</code>: The maximum number of security groups
- *           that you can assign to a network interface.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>max-elastic-ips</code>: The maximum number of Elastic IP addresses that you can
- *           allocate for use with EC2-Classic. </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <code>vpc-max-elastic-ips</code>: The maximum number of Elastic IP addresses that you can
- *           allocate for use with EC2-VPC.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeAccountAttributesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeAccountAttributesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeAccountAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccountAttributesCommandInput} for command's `input` shape.
- * @see {@link DescribeAccountAttributesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAccountAttributesCommand extends $Command<DescribeAccountAttributesCommandInput, DescribeAccountAttributesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeAccountAttributesCommandInput;
     constructor(input: DescribeAccountAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccountAttributesCommandInput, DescribeAccountAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeAddressesAttributeCommandInput extends DescribeAddresse
 }
 export interface DescribeAddressesAttributeCommandOutput extends DescribeAddressesAttributeResult, __MetadataBearer {
 }
-/**
- * <p>Describes the attributes of the specified Elastic IP addresses. For requirements, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS">Using reverse DNS for email applications</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeAddressesAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeAddressesAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeAddressesAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAddressesAttributeCommandInput} for command's `input` shape.
- * @see {@link DescribeAddressesAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAddressesAttributeCommand extends $Command<DescribeAddressesAttributeCommandInput, DescribeAddressesAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeAddressesAttributeCommandInput;
     constructor(input: DescribeAddressesAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAddressesAttributeCommandInput, DescribeAddressesAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeAddressesCommandInput extends DescribeAddressesRequest
 }
 export interface DescribeAddressesCommandOutput extends DescribeAddressesResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified Elastic IP addresses or all of your Elastic IP addresses.</p>
- *          <p>An Elastic IP address is for use in either the EC2-Classic platform or in a VPC.
- * 				For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic IP Addresses</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeAddressesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeAddressesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeAddressesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAddressesCommandInput} for command's `input` shape.
- * @see {@link DescribeAddressesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAddressesCommand extends $Command<DescribeAddressesCommandInput, DescribeAddressesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeAddressesCommandInput;
     constructor(input: DescribeAddressesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAddressesCommandInput, DescribeAddressesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface DescribeAggregateIdFormatCommandInput extends DescribeAggregate
 }
 export interface DescribeAggregateIdFormatCommandOutput extends DescribeAggregateIdFormatResult, __MetadataBearer {
 }
-/**
- * <p>Describes the longer ID format settings for all resource types in a specific
- *          Region. This request is useful for performing a quick audit to determine whether a
- *          specific Region is fully opted in for longer IDs (17-character IDs).</p>
- *
- *          <p>This request only returns information about resource types that support longer IDs.</p>
- *          <p>The following resource types support longer IDs: <code>bundle</code> |
- *         <code>conversion-task</code> | <code>customer-gateway</code> | <code>dhcp-options</code> |
- *         <code>elastic-ip-allocation</code> | <code>elastic-ip-association</code> |
- *         <code>export-task</code> | <code>flow-log</code> | <code>image</code> |
- *         <code>import-task</code> | <code>instance</code> | <code>internet-gateway</code> |
- *         <code>network-acl</code> | <code>network-acl-association</code> |
- *         <code>network-interface</code> | <code>network-interface-attachment</code> |
- *         <code>prefix-list</code> | <code>reservation</code> | <code>route-table</code> |
- *         <code>route-table-association</code> | <code>security-group</code> |
- *         <code>snapshot</code> | <code>subnet</code> |
- *         <code>subnet-cidr-block-association</code> | <code>volume</code> | <code>vpc</code> |
- *         <code>vpc-cidr-block-association</code> | <code>vpc-endpoint</code> |
- *         <code>vpc-peering-connection</code> | <code>vpn-connection</code> | <code>vpn-gateway</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeAggregateIdFormatCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeAggregateIdFormatCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeAggregateIdFormatCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAggregateIdFormatCommandInput} for command's `input` shape.
- * @see {@link DescribeAggregateIdFormatCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAggregateIdFormatCommand extends $Command<DescribeAggregateIdFormatCommandInput, DescribeAggregateIdFormatCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeAggregateIdFormatCommandInput;
     constructor(input: DescribeAggregateIdFormatCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAggregateIdFormatCommandInput, DescribeAggregateIdFormatCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DescribeAvailabilityZonesCommandInput extends DescribeAvailabil
 }
 export interface DescribeAvailabilityZonesCommandOutput extends DescribeAvailabilityZonesResult, __MetadataBearer {
 }
-/**
- * <p>Describes the Availability Zones, Local Zones, and Wavelength Zones that are available to
- *       you. If there is an event impacting a zone, you can use this request to view the state and any
- *       provided messages for that zone.</p>
- *          <p>For more information about Availability Zones, Local Zones, and Wavelength Zones, see
- *         <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html">Regions, Zones and
- *         Outposts</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeAvailabilityZonesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeAvailabilityZonesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeAvailabilityZonesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAvailabilityZonesCommandInput} for command's `input` shape.
- * @see {@link DescribeAvailabilityZonesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAvailabilityZonesCommand extends $Command<DescribeAvailabilityZonesCommandInput, DescribeAvailabilityZonesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeAvailabilityZonesCommandInput;
     constructor(input: DescribeAvailabilityZonesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAvailabilityZonesCommandInput, DescribeAvailabilityZonesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeBundleTasksCommandInput extends DescribeBundleTasksRequ
 }
 export interface DescribeBundleTasksCommandOutput extends DescribeBundleTasksResult, __MetadataBearer {
 }
-/**
- * <p>Describes the specified bundle tasks or all of your bundle tasks.</p>
- *          <note>
- *             <p>Completed bundle tasks are listed for only a limited time. If your bundle task is no longer in the list, you can still register an AMI from it. Just use <code>RegisterImage</code> with the Amazon S3 bucket name and image manifest name you provided to the bundle task.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeBundleTasksCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeBundleTasksCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeBundleTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeBundleTasksCommandInput} for command's `input` shape.
- * @see {@link DescribeBundleTasksCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeBundleTasksCommand extends $Command<DescribeBundleTasksCommandInput, DescribeBundleTasksCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeBundleTasksCommandInput;
     constructor(input: DescribeBundleTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeBundleTasksCommandInput, DescribeBundleTasksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeByoipCidrsCommandInput extends DescribeByoipCidrsReques
 }
 export interface DescribeByoipCidrsCommandOutput extends DescribeByoipCidrsResult, __MetadataBearer {
 }
-/**
- * <p>Describes the IP address ranges that were specified in calls to <a>ProvisionByoipCidr</a>.</p>
- *          <p>To describe the address pools that were created when you provisioned the address
- *           ranges, use <a>DescribePublicIpv4Pools</a> or <a>DescribeIpv6Pools</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeByoipCidrsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeByoipCidrsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeByoipCidrsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeByoipCidrsCommandInput} for command's `input` shape.
- * @see {@link DescribeByoipCidrsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeByoipCidrsCommand extends $Command<DescribeByoipCidrsCommandInput, DescribeByoipCidrsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeByoipCidrsCommandInput;
     constructor(input: DescribeByoipCidrsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeByoipCidrsCommandInput, DescribeByoipCidrsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeCapacityReservationFleetsCommandInput extends DescribeC
 }
 export interface DescribeCapacityReservationFleetsCommandOutput extends DescribeCapacityReservationFleetsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Capacity Reservation Fleets.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeCapacityReservationFleetsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeCapacityReservationFleetsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeCapacityReservationFleetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCapacityReservationFleetsCommandInput} for command's `input` shape.
- * @see {@link DescribeCapacityReservationFleetsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCapacityReservationFleetsCommand extends $Command<DescribeCapacityReservationFleetsCommandInput, DescribeCapacityReservationFleetsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeCapacityReservationFleetsCommandInput;
     constructor(input: DescribeCapacityReservationFleetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCapacityReservationFleetsCommandInput, DescribeCapacityReservationFleetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeCapacityReservationsCommandInput extends DescribeCapaci
 }
 export interface DescribeCapacityReservationsCommandOutput extends DescribeCapacityReservationsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your Capacity Reservations. The results describe only the Capacity Reservations in the
- * 		    	Amazon Web Services Region that you're currently using.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeCapacityReservationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeCapacityReservationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeCapacityReservationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCapacityReservationsCommandInput} for command's `input` shape.
- * @see {@link DescribeCapacityReservationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCapacityReservationsCommand extends $Command<DescribeCapacityReservationsCommandInput, DescribeCapacityReservationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeCapacityReservationsCommandInput;
     constructor(input: DescribeCapacityReservationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCapacityReservationsCommandInput, DescribeCapacityReservationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeCarrierGatewaysCommandInput extends DescribeCarrierGate
 }
 export interface DescribeCarrierGatewaysCommandOutput extends DescribeCarrierGatewaysResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your carrier gateways.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeCarrierGatewaysCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeCarrierGatewaysCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeCarrierGatewaysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCarrierGatewaysCommandInput} for command's `input` shape.
- * @see {@link DescribeCarrierGatewaysCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCarrierGatewaysCommand extends $Command<DescribeCarrierGatewaysCommandInput, DescribeCarrierGatewaysCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeCarrierGatewaysCommandInput;
     constructor(input: DescribeCarrierGatewaysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCarrierGatewaysCommandInput, DescribeCarrierGatewaysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeClassicLinkInstancesCommandInput extends DescribeClassi
 }
 export interface DescribeClassicLinkInstancesCommandOutput extends DescribeClassicLinkInstancesResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your linked EC2-Classic instances. This request only returns
- * 			information about EC2-Classic instances linked to a VPC through ClassicLink. You cannot
- * 			use this request to return information about other instances.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeClassicLinkInstancesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeClassicLinkInstancesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeClassicLinkInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClassicLinkInstancesCommandInput} for command's `input` shape.
- * @see {@link DescribeClassicLinkInstancesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClassicLinkInstancesCommand extends $Command<DescribeClassicLinkInstancesCommandInput, DescribeClassicLinkInstancesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeClassicLinkInstancesCommandInput;
     constructor(input: DescribeClassicLinkInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClassicLinkInstancesCommandInput, DescribeClassicLinkInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeClientVpnAuthorizationRulesCommandInput extends Describ
 }
 export interface DescribeClientVpnAuthorizationRulesCommandOutput extends DescribeClientVpnAuthorizationRulesResult, __MetadataBearer {
 }
-/**
- * <p>Describes the authorization rules for a specified Client VPN endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeClientVpnAuthorizationRulesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeClientVpnAuthorizationRulesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeClientVpnAuthorizationRulesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClientVpnAuthorizationRulesCommandInput} for command's `input` shape.
- * @see {@link DescribeClientVpnAuthorizationRulesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClientVpnAuthorizationRulesCommand extends $Command<DescribeClientVpnAuthorizationRulesCommandInput, DescribeClientVpnAuthorizationRulesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeClientVpnAuthorizationRulesCommandInput;
     constructor(input: DescribeClientVpnAuthorizationRulesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClientVpnAuthorizationRulesCommandInput, DescribeClientVpnAuthorizationRulesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeClientVpnConnectionsCommandInput extends DescribeClient
 }
 export interface DescribeClientVpnConnectionsCommandOutput extends DescribeClientVpnConnectionsResult, __MetadataBearer {
 }
-/**
- * <p>Describes active client connections and connections that have been terminated within the last 60
- * 			minutes for the specified Client VPN endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeClientVpnConnectionsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeClientVpnConnectionsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeClientVpnConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClientVpnConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeClientVpnConnectionsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClientVpnConnectionsCommand extends $Command<DescribeClientVpnConnectionsCommandInput, DescribeClientVpnConnectionsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeClientVpnConnectionsCommandInput;
     constructor(input: DescribeClientVpnConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClientVpnConnectionsCommandInput, DescribeClientVpnConnectionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeClientVpnEndpointsCommandInput extends DescribeClientVp
 }
 export interface DescribeClientVpnEndpointsCommandOutput extends DescribeClientVpnEndpointsResult, __MetadataBearer {
 }
-/**
- * <p>Describes one or more Client VPN endpoints in the account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, DescribeClientVpnEndpointsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, DescribeClientVpnEndpointsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new DescribeClientVpnEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClientVpnEndpointsCommandInput} for command's `input` shape.
- * @see {@link DescribeClientVpnEndpointsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClientVpnEndpointsCommand extends $Command<DescribeClientVpnEndpointsCommandInput, DescribeClientVpnEndpointsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: DescribeClientVpnEndpointsCommandInput;
     constructor(input: DescribeClientVpnEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClientVpnEndpointsCommandInput, DescribeClientVpnEndpointsCommandOutput>;
     private serialize;
     private deserialize;