@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,32 +6,11 @@ export interface CancelReservedInstancesListingCommandInput extends CancelReserv
 }
 export interface CancelReservedInstancesListingCommandOutput extends CancelReservedInstancesListingResult, __MetadataBearer {
 }
-/**
- * <p>Cancels the specified Reserved Instance listing in the Reserved Instance Marketplace.</p>
- *          <p>For more information, see
- *         <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved Instance Marketplace</a>
- *         in the <i>Amazon EC2 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelReservedInstancesListingCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelReservedInstancesListingCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelReservedInstancesListingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelReservedInstancesListingCommandInput} for command's `input` shape.
- * @see {@link CancelReservedInstancesListingCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelReservedInstancesListingCommand extends $Command<CancelReservedInstancesListingCommandInput, CancelReservedInstancesListingCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelReservedInstancesListingCommandInput;
     constructor(input: CancelReservedInstancesListingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelReservedInstancesListingCommandInput, CancelReservedInstancesListingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface CancelSpotFleetRequestsCommandInput extends CancelSpotFleetRequ
 }
 export interface CancelSpotFleetRequestsCommandOutput extends CancelSpotFleetRequestsResponse, __MetadataBearer {
 }
-/**
- * <p>Cancels the specified Spot Fleet requests.</p>
- *         <p>After you cancel a Spot Fleet request, the Spot Fleet launches no new Spot Instances.
- *             You must specify whether the Spot Fleet should also terminate its Spot Instances. If you
- *             terminate the instances, the Spot Fleet request enters the
- *                 <code>cancelled_terminating</code> state. Otherwise, the Spot Fleet request enters
- *             the <code>cancelled_running</code> state and the instances continue to run until they
- *             are interrupted or you terminate them manually.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelSpotFleetRequestsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelSpotFleetRequestsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelSpotFleetRequestsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelSpotFleetRequestsCommandInput} for command's `input` shape.
- * @see {@link CancelSpotFleetRequestsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelSpotFleetRequestsCommand extends $Command<CancelSpotFleetRequestsCommandInput, CancelSpotFleetRequestsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelSpotFleetRequestsCommandInput;
     constructor(input: CancelSpotFleetRequestsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelSpotFleetRequestsCommandInput, CancelSpotFleetRequestsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface CancelSpotInstanceRequestsCommandInput extends CancelSpotInstan
 }
 export interface CancelSpotInstanceRequestsCommandOutput extends CancelSpotInstanceRequestsResult, __MetadataBearer {
 }
-/**
- * <p>Cancels one or more Spot Instance requests.</p>
- *         <important>
- *             <p>Canceling a Spot Instance request does not terminate running Spot Instances
- *                 associated with the request.</p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CancelSpotInstanceRequestsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CancelSpotInstanceRequestsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CancelSpotInstanceRequestsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelSpotInstanceRequestsCommandInput} for command's `input` shape.
- * @see {@link CancelSpotInstanceRequestsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelSpotInstanceRequestsCommand extends $Command<CancelSpotInstanceRequestsCommandInput, CancelSpotInstanceRequestsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CancelSpotInstanceRequestsCommandInput;
     constructor(input: CancelSpotInstanceRequestsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelSpotInstanceRequestsCommandInput, CancelSpotInstanceRequestsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ConfirmProductInstanceCommandInput extends ConfirmProductInstan
 }
 export interface ConfirmProductInstanceCommandOutput extends ConfirmProductInstanceResult, __MetadataBearer {
 }
-/**
- * <p>Determines whether a product code is associated with an instance. This action can only
- *             be used by the owner of the product code. It is useful when a product code owner must
- *             verify whether another user's instance is eligible for support.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ConfirmProductInstanceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ConfirmProductInstanceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ConfirmProductInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ConfirmProductInstanceCommandInput} for command's `input` shape.
- * @see {@link ConfirmProductInstanceCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ConfirmProductInstanceCommand extends $Command<ConfirmProductInstanceCommandInput, ConfirmProductInstanceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ConfirmProductInstanceCommandInput;
     constructor(input: ConfirmProductInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfirmProductInstanceCommandInput, ConfirmProductInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CopyFpgaImageCommandInput extends CopyFpgaImageRequest {
 }
 export interface CopyFpgaImageCommandOutput extends CopyFpgaImageResult, __MetadataBearer {
 }
-/**
- * <p>Copies the specified Amazon FPGA Image (AFI) to the current Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CopyFpgaImageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CopyFpgaImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CopyFpgaImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CopyFpgaImageCommandInput} for command's `input` shape.
- * @see {@link CopyFpgaImageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CopyFpgaImageCommand extends $Command<CopyFpgaImageCommandInput, CopyFpgaImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CopyFpgaImageCommandInput;
     constructor(input: CopyFpgaImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyFpgaImageCommandInput, CopyFpgaImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,50 +6,11 @@ export interface CopyImageCommandInput extends CopyImageRequest {
 }
 export interface CopyImageCommandOutput extends CopyImageResult, __MetadataBearer {
 }
-/**
- * <p>Initiates the copy of an AMI. You can copy an AMI from one Region to another, or from a
- *       Region to an Outpost. You can't copy an AMI from an Outpost to a Region, from one Outpost
- *       to another, or within the same Outpost. To copy an AMI to another partition, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html">CreateStoreImageTask</a>.</p>
- *
- *      	   <p>To copy an AMI from one Region to another, specify the source Region using the
- *      		<b>SourceRegion</b> parameter, and specify the
- *      		destination Region using its endpoint. Copies of encrypted backing snapshots for
- *      		the AMI are encrypted. Copies of unencrypted backing snapshots remain unencrypted,
- *      		unless you set <code>Encrypted</code> during the copy operation. You cannot
- *      		create an unencrypted copy of an encrypted backing snapshot.</p>
- *
- *    	     <p>To copy an AMI from a Region to an Outpost, specify the source Region using the
- *    		<b>SourceRegion</b> parameter, and specify the
- *    		ARN of the destination Outpost using <b>DestinationOutpostArn</b>.
- *    		Backing snapshots copied to an Outpost are encrypted by default using the default
- *    		encryption key for the Region, or a different key that you specify in the request using
- *    		<b>KmsKeyId</b>. Outposts do not support unencrypted
- *    		snapshots. For more information, <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshots-outposts.html#ami">
- *    			Amazon EBS local snapshots on Outposts</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *
- *          <p>For more information about the prerequisites and limits when copying an AMI, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html">Copying an AMI</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, CopyImageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CopyImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CopyImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CopyImageCommandInput} for command's `input` shape.
- * @see {@link CopyImageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CopyImageCommand extends $Command<CopyImageCommandInput, CopyImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CopyImageCommandInput;
     constructor(input: CopyImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyImageCommandInput, CopyImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,51 +6,11 @@ export interface CopySnapshotCommandInput extends CopySnapshotRequest {
 }
 export interface CopySnapshotCommandOutput extends CopySnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Copies a point-in-time snapshot of an EBS volume and stores it in Amazon S3. You can copy a
- *       snapshot within the same Region, from one Region to another, or from a Region to an Outpost.
- *       You can't copy a snapshot from an Outpost to a Region, from one Outpost to another, or within
- *       the same Outpost.</p>
- *          <p>You can use the snapshot to create EBS volumes or Amazon Machine Images (AMIs).</p>
- *
- *
- *          <p>When copying snapshots to a Region, copies of encrypted EBS snapshots remain encrypted.
- *     	Copies of unencrypted snapshots remain unencrypted, unless you enable encryption for the
- *     	snapshot copy operation. By default, encrypted snapshot copies use the default Key Management Service (KMS)
- *     	KMS key; however, you can specify a different KMS key. To copy an encrypted
- *     	snapshot that has been shared from another account, you must have permissions for the KMS key
- *     	used to encrypt the snapshot.</p>
- *
- *   	      <p>Snapshots copied to an Outpost are encrypted by default using the default
- *   		encryption key for the Region, or a different key that you specify in the request using
- *   		<b>KmsKeyId</b>. Outposts do not support unencrypted
- *   		snapshots. For more information, <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshots-outposts.html#ami">
- *   			Amazon EBS local snapshots on Outposts</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
- *          <p>Snapshots created by copying another snapshot have an arbitrary volume ID that should not
- *       be used for any purpose.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-copy-snapshot.html">Copy an Amazon EBS snapshot</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, CopySnapshotCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CopySnapshotCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CopySnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CopySnapshotCommandInput} for command's `input` shape.
- * @see {@link CopySnapshotCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CopySnapshotCommand extends $Command<CopySnapshotCommandInput, CopySnapshotCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CopySnapshotCommandInput;
     constructor(input: CopySnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopySnapshotCommandInput, CopySnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,45 +6,11 @@ export interface CreateCapacityReservationCommandInput extends CreateCapacityRes
 }
 export interface CreateCapacityReservationCommandOutput extends CreateCapacityReservationResult, __MetadataBearer {
 }
-/**
- * <p>Creates a new Capacity Reservation with the specified attributes.</p>
- * 		       <p>Capacity Reservations enable you to reserve capacity for your Amazon EC2 instances in a specific Availability Zone for any duration. This
- * 			gives you the flexibility to selectively add capacity reservations and still get the Regional RI discounts for that usage.
- * 			By creating Capacity Reservations, you ensure that you always have access to Amazon EC2 capacity when you need it, for as long as you need it.
- * 			For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-reservations.html">Capacity Reservations</a> in the <i>Amazon EC2 User Guide</i>.</p>
- *
- * 		       <p>Your request to create a Capacity Reservation could fail if Amazon EC2 does not have sufficient capacity to
- * 			fulfill the request. If your request fails due to Amazon EC2 capacity constraints, either try
- * 			again at a later time, try in a different Availability Zone, or request a smaller
- * 			capacity reservation. If your application is flexible across instance types and sizes,
- * 			try to create a Capacity Reservation with different instance attributes.</p>
- *
- * 		       <p>Your request could also fail if the requested quantity exceeds your On-Demand Instance
- * 			limit for the selected instance type. If your request fails due to limit constraints,
- * 			increase your On-Demand Instance limit for the required instance type and try again. For
- * 			more information about increasing your instance limits, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html">Amazon EC2 Service
- * 				Quotas</a> in the <i>Amazon EC2 User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateCapacityReservationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateCapacityReservationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateCapacityReservationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateCapacityReservationCommandInput} for command's `input` shape.
- * @see {@link CreateCapacityReservationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateCapacityReservationCommand extends $Command<CreateCapacityReservationCommandInput, CreateCapacityReservationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateCapacityReservationCommandInput;
     constructor(input: CreateCapacityReservationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCapacityReservationCommandInput, CreateCapacityReservationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateCapacityReservationFleetCommandInput extends CreateCapaci
 }
 export interface CreateCapacityReservationFleetCommandOutput extends CreateCapacityReservationFleetResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Capacity Reservation Fleet. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-cr-fleets.html#create-crfleet">Create a Capacity
- * 			Reservation Fleet</a> in the Amazon EC2 User Guide.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateCapacityReservationFleetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateCapacityReservationFleetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateCapacityReservationFleetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateCapacityReservationFleetCommandInput} for command's `input` shape.
- * @see {@link CreateCapacityReservationFleetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateCapacityReservationFleetCommand extends $Command<CreateCapacityReservationFleetCommandInput, CreateCapacityReservationFleetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateCapacityReservationFleetCommandInput;
     constructor(input: CreateCapacityReservationFleetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCapacityReservationFleetCommandInput, CreateCapacityReservationFleetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateCarrierGatewayCommandInput extends CreateCarrierGatewayRe
 }
 export interface CreateCarrierGatewayCommandOutput extends CreateCarrierGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Creates a carrier gateway.   For more information about carrier gateways, see <a href="https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#wavelength-carrier-gateway">Carrier gateways</a> in the <i>Amazon Web Services Wavelength Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateCarrierGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateCarrierGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateCarrierGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateCarrierGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateCarrierGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateCarrierGatewayCommand extends $Command<CreateCarrierGatewayCommandInput, CreateCarrierGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateCarrierGatewayCommandInput;
     constructor(input: CreateCarrierGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCarrierGatewayCommandInput, CreateCarrierGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateClientVpnEndpointCommandInput extends CreateClientVpnEndp
 }
 export interface CreateClientVpnEndpointCommandOutput extends CreateClientVpnEndpointResult, __MetadataBearer {
 }
-/**
- * <p>Creates a Client VPN endpoint. A Client VPN endpoint is the resource you create and configure to
- * 			enable and manage client VPN sessions. It is the destination endpoint at which all client VPN sessions
- * 			are terminated.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateClientVpnEndpointCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateClientVpnEndpointCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateClientVpnEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateClientVpnEndpointCommandInput} for command's `input` shape.
- * @see {@link CreateClientVpnEndpointCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateClientVpnEndpointCommand extends $Command<CreateClientVpnEndpointCommandInput, CreateClientVpnEndpointCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateClientVpnEndpointCommandInput;
     constructor(input: CreateClientVpnEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClientVpnEndpointCommandInput, CreateClientVpnEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateClientVpnRouteCommandInput extends CreateClientVpnRouteRe
 }
 export interface CreateClientVpnRouteCommandOutput extends CreateClientVpnRouteResult, __MetadataBearer {
 }
-/**
- * <p>Adds a route to a network to a Client VPN endpoint. Each Client VPN endpoint has a route table that describes the
- * 			available destination network routes. Each route in the route table specifies the path for traffic to specific resources or networks.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateClientVpnRouteCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateClientVpnRouteCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateClientVpnRouteCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateClientVpnRouteCommandInput} for command's `input` shape.
- * @see {@link CreateClientVpnRouteCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateClientVpnRouteCommand extends $Command<CreateClientVpnRouteCommandInput, CreateClientVpnRouteCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateClientVpnRouteCommandInput;
     constructor(input: CreateClientVpnRouteCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClientVpnRouteCommandInput, CreateClientVpnRouteCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,64 +6,11 @@ export interface CreateCustomerGatewayCommandInput extends CreateCustomerGateway
 }
 export interface CreateCustomerGatewayCommandOutput extends CreateCustomerGatewayResult, __MetadataBearer {
 }
-/**
- * <p>Provides information to Amazon Web Services about your VPN customer gateway device. The
- *             customer gateway is the appliance at your end of the VPN connection. (The device on the
- *                 Amazon Web Services side of the VPN connection is the virtual private gateway.) You
- *             must provide the internet-routable IP address of the customer gateway's external
- *             interface. The IP address must be static and can be behind a device performing network
- *             address translation (NAT).</p>
- *         <p>For devices that use Border Gateway Protocol (BGP), you can also provide the device's
- *             BGP Autonomous System Number (ASN). You can use an existing ASN assigned to your
- *             network. If you don't have an ASN already, you can use a private ASN (in the 64512 -
- *             65534 range).</p>
- *         <note>
- *             <p>Amazon EC2 supports all 4-byte ASN numbers in the range of 1 - 2147483647, with
- *                 the exception of the following:</p>
- *             <ul>
- *                <li>
- *                     <p>7224 - reserved in the <code>us-east-1</code> Region</p>
- *                 </li>
- *                <li>
- *                     <p>9059 - reserved in the <code>eu-west-1</code> Region</p>
- *                 </li>
- *                <li>
- *                     <p>17943 - reserved in the <code>ap-southeast-1</code> Region</p>
- *                 </li>
- *                <li>
- *                     <p>10124 - reserved in the <code>ap-northeast-1</code> Region</p>
- *                 </li>
- *             </ul>
- *         </note>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN
- *                 User Guide</i>.</p>
- *         <important>
- *             <p>To create more than one customer gateway with the same VPN type, IP address, and
- *                 BGP ASN, specify a unique device name for each customer gateway. Identical requests
- *                 return information about the existing customer gateway and do not create new
- *                 customer gateways.</p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateCustomerGatewayCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateCustomerGatewayCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateCustomerGatewayCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateCustomerGatewayCommandInput} for command's `input` shape.
- * @see {@link CreateCustomerGatewayCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateCustomerGatewayCommand extends $Command<CreateCustomerGatewayCommandInput, CreateCustomerGatewayCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateCustomerGatewayCommandInput;
     constructor(input: CreateCustomerGatewayCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCustomerGatewayCommandInput, CreateCustomerGatewayCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateDefaultSubnetCommandInput extends CreateDefaultSubnetRequ
 }
 export interface CreateDefaultSubnetCommandOutput extends CreateDefaultSubnetResult, __MetadataBearer {
 }
-/**
- * <p>Creates a default subnet with a size <code>/20</code> IPv4 CIDR block in the
- *             specified Availability Zone in your default VPC. You can have only one default subnet
- *             per Availability Zone. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-subnet">Creating a default
- *                 subnet</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateDefaultSubnetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateDefaultSubnetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateDefaultSubnetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDefaultSubnetCommandInput} for command's `input` shape.
- * @see {@link CreateDefaultSubnetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDefaultSubnetCommand extends $Command<CreateDefaultSubnetCommandInput, CreateDefaultSubnetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateDefaultSubnetCommandInput;
     constructor(input: CreateDefaultSubnetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDefaultSubnetCommandInput, CreateDefaultSubnetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface CreateDefaultVpcCommandInput extends CreateDefaultVpcRequest {
 }
 export interface CreateDefaultVpcCommandOutput extends CreateDefaultVpcResult, __MetadataBearer {
 }
-/**
- * <p>Creates a default VPC with a size <code>/16</code> IPv4 CIDR block and a default subnet
- * 			in each Availability Zone. For more information about the components of a default VPC,
- * 			see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html">Default VPC and
- * 			default subnets</a> in the <i>Amazon Virtual Private Cloud User Guide</i>. You cannot
- * 			specify the components of the default VPC yourself.</p>
- * 		       <p>If you deleted your previous default VPC, you can create a default VPC. You cannot have
- * 			more than one default VPC per Region.</p>
- * 		       <p>If your account supports EC2-Classic, you cannot use this action to create a default VPC
- * 			in a Region that supports EC2-Classic. If you want a default VPC in a Region that
- * 			supports EC2-Classic, see "I really want a default VPC for my existing EC2 account. Is
- * 			that possible?" in the <a href="http://aws.amazon.com/vpc/faqs/#Default_VPCs">Default VPCs
- * 			FAQ</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, CreateDefaultVpcCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, CreateDefaultVpcCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new CreateDefaultVpcCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDefaultVpcCommandInput} for command's `input` shape.
- * @see {@link CreateDefaultVpcCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDefaultVpcCommand extends $Command<CreateDefaultVpcCommandInput, CreateDefaultVpcCommandOutput, EC2ClientResolvedConfig> {
     readonly input: CreateDefaultVpcCommandInput;
     constructor(input: CreateDefaultVpcCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDefaultVpcCommandInput, CreateDefaultVpcCommandOutput>;
     private serialize;
     private deserialize;