@aws-sdk/client-ec2 3.36.0 → 3.39.0

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

@@ -6,29 +6,11 @@ export interface GetSubnetCidrReservationsCommandInput extends GetSubnetCidrRese
 }
 export interface GetSubnetCidrReservationsCommandOutput extends GetSubnetCidrReservationsResult, __MetadataBearer {
 }
-/**
- * <p>Gets information about the subnet CIDR reservations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetSubnetCidrReservationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetSubnetCidrReservationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetSubnetCidrReservationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSubnetCidrReservationsCommandInput} for command's `input` shape.
- * @see {@link GetSubnetCidrReservationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSubnetCidrReservationsCommand extends $Command<GetSubnetCidrReservationsCommandInput, GetSubnetCidrReservationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetSubnetCidrReservationsCommandInput;
     constructor(input: GetSubnetCidrReservationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSubnetCidrReservationsCommandInput, GetSubnetCidrReservationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetTransitGatewayAttachmentPropagationsCommandInput extends Get
 }
 export interface GetTransitGatewayAttachmentPropagationsCommandOutput extends GetTransitGatewayAttachmentPropagationsResult, __MetadataBearer {
 }
-/**
- * <p>Lists the route tables to which the specified resource attachment propagates routes.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetTransitGatewayAttachmentPropagationsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetTransitGatewayAttachmentPropagationsCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetTransitGatewayAttachmentPropagationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetTransitGatewayAttachmentPropagationsCommandInput} for command's `input` shape.
- * @see {@link GetTransitGatewayAttachmentPropagationsCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetTransitGatewayAttachmentPropagationsCommand extends $Command<GetTransitGatewayAttachmentPropagationsCommandInput, GetTransitGatewayAttachmentPropagationsCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetTransitGatewayAttachmentPropagationsCommandInput;
     constructor(input: GetTransitGatewayAttachmentPropagationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTransitGatewayAttachmentPropagationsCommandInput, GetTransitGatewayAttachmentPropagationsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface GetTransitGatewayPrefixListReferencesCommandInput extends GetTr
 }
 export interface GetTransitGatewayPrefixListReferencesCommandOutput extends GetTransitGatewayPrefixListReferencesResult, __MetadataBearer {
 }
-/**
- * <p>Gets information about the prefix list references in a specified transit gateway route table.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetTransitGatewayPrefixListReferencesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetTransitGatewayPrefixListReferencesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetTransitGatewayPrefixListReferencesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetTransitGatewayPrefixListReferencesCommandInput} for command's `input` shape.
- * @see {@link GetTransitGatewayPrefixListReferencesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetTransitGatewayPrefixListReferencesCommand extends $Command<GetTransitGatewayPrefixListReferencesCommandInput, GetTransitGatewayPrefixListReferencesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetTransitGatewayPrefixListReferencesCommandInput;
     constructor(input: GetTransitGatewayPrefixListReferencesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTransitGatewayPrefixListReferencesCommandInput, GetTransitGatewayPrefixListReferencesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface GetVpnConnectionDeviceSampleConfigurationCommandInput extends G
 }
 export interface GetVpnConnectionDeviceSampleConfigurationCommandOutput extends GetVpnConnectionDeviceSampleConfigurationResult, __MetadataBearer {
 }
-/**
- * <p>Download an AWS-provided sample configuration file to be used with the customer
- *             gateway device specified for your Site-to-Site VPN connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetVpnConnectionDeviceSampleConfigurationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetVpnConnectionDeviceSampleConfigurationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetVpnConnectionDeviceSampleConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetVpnConnectionDeviceSampleConfigurationCommandInput} for command's `input` shape.
- * @see {@link GetVpnConnectionDeviceSampleConfigurationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetVpnConnectionDeviceSampleConfigurationCommand extends $Command<GetVpnConnectionDeviceSampleConfigurationCommandInput, GetVpnConnectionDeviceSampleConfigurationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetVpnConnectionDeviceSampleConfigurationCommandInput;
     constructor(input: GetVpnConnectionDeviceSampleConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpnConnectionDeviceSampleConfigurationCommandInput, GetVpnConnectionDeviceSampleConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetVpnConnectionDeviceTypesCommandInput extends GetVpnConnectio
 }
 export interface GetVpnConnectionDeviceTypesCommandOutput extends GetVpnConnectionDeviceTypesResult, __MetadataBearer {
 }
-/**
- * <p>Obtain a list of customer gateway devices for which sample configuration
- *             files can be provided. The request has no additional parameters. You can also see the
- *             list of device types with sample configuration files available under <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/your-cgw.html">Your customer gateway
- *                 device</a> in the <i>Amazon Web Services Site-to-Site VPN User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, GetVpnConnectionDeviceTypesCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, GetVpnConnectionDeviceTypesCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new GetVpnConnectionDeviceTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetVpnConnectionDeviceTypesCommandInput} for command's `input` shape.
- * @see {@link GetVpnConnectionDeviceTypesCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetVpnConnectionDeviceTypesCommand extends $Command<GetVpnConnectionDeviceTypesCommandInput, GetVpnConnectionDeviceTypesCommandOutput, EC2ClientResolvedConfig> {
     readonly input: GetVpnConnectionDeviceTypesCommandInput;
     constructor(input: GetVpnConnectionDeviceTypesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVpnConnectionDeviceTypesCommandInput, GetVpnConnectionDeviceTypesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ImportClientVpnClientCertificateRevocationListCommandInput exte
 }
 export interface ImportClientVpnClientCertificateRevocationListCommandOutput extends ImportClientVpnClientCertificateRevocationListResult, __MetadataBearer {
 }
-/**
- * <p>Uploads a client certificate revocation list to the specified Client VPN endpoint. Uploading a client certificate revocation list overwrites the existing client certificate revocation list.</p>
- * 		       <p>Uploading a client certificate revocation list resets existing client connections.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ImportClientVpnClientCertificateRevocationListCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ImportClientVpnClientCertificateRevocationListCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ImportClientVpnClientCertificateRevocationListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportClientVpnClientCertificateRevocationListCommandInput} for command's `input` shape.
- * @see {@link ImportClientVpnClientCertificateRevocationListCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportClientVpnClientCertificateRevocationListCommand extends $Command<ImportClientVpnClientCertificateRevocationListCommandInput, ImportClientVpnClientCertificateRevocationListCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ImportClientVpnClientCertificateRevocationListCommandInput;
     constructor(input: ImportClientVpnClientCertificateRevocationListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportClientVpnClientCertificateRevocationListCommandInput, ImportClientVpnClientCertificateRevocationListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ImportImageCommandInput extends ImportImageRequest {
 }
 export interface ImportImageCommandOutput extends ImportImageResult, __MetadataBearer {
 }
-/**
- * <p>Import single or multi-volume disk images or EBS snapshots into an Amazon Machine Image (AMI).</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-image-import.html">Importing a
- *    VM as an image using VM Import/Export</a> in the <i>VM Import/Export User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ImportImageCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ImportImageCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ImportImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportImageCommandInput} for command's `input` shape.
- * @see {@link ImportImageCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportImageCommand extends $Command<ImportImageCommandInput, ImportImageCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ImportImageCommandInput;
     constructor(input: ImportImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportImageCommandInput, ImportImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ImportInstanceCommandInput extends ImportInstanceRequest {
 }
 export interface ImportInstanceCommandOutput extends ImportInstanceResult, __MetadataBearer {
 }
-/**
- * <p>Creates an import instance task using metadata from the specified disk image.</p>
- *          <p>This API action supports only single-volume VMs. To import multi-volume VMs, use <a>ImportImage</a>
- *    instead.</p>
- *          <p>This API action is not supported by the Command Line Interface (CLI). For
- *    information about using the Amazon EC2 CLI, which is deprecated, see
- *    <a href="https://awsdocs.s3.amazonaws.com/EC2/ec2-clt.pdf#UsingVirtualMachinesinAmazonEC2">Importing a VM to Amazon EC2</a> in the <i>Amazon EC2 CLI Reference</i> PDF file.</p>
- *          <p>For information about the import manifest referenced by this API action, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM Import Manifest</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ImportInstanceCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ImportInstanceCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ImportInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportInstanceCommandInput} for command's `input` shape.
- * @see {@link ImportInstanceCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportInstanceCommand extends $Command<ImportInstanceCommandInput, ImportInstanceCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ImportInstanceCommandInput;
     constructor(input: ImportInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportInstanceCommandInput, ImportInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface ImportKeyPairCommandInput extends ImportKeyPairRequest {
 }
 export interface ImportKeyPairCommandOutput extends ImportKeyPairResult, __MetadataBearer {
 }
-/**
- * <p>Imports the public key from an RSA or ED25519 key pair that you created with a third-party tool.
- *         Compare this with <a>CreateKeyPair</a>, in which Amazon Web Services creates the key pair and gives the keys to you
- *         (Amazon Web Services keeps a copy of the public key). With ImportKeyPair, you create the key pair and give Amazon Web Services just the public key.
- *         The private key is never transferred between you and Amazon Web Services.</p>
- *          <p>For more information about key pairs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon EC2 key pairs</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, ImportKeyPairCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ImportKeyPairCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ImportKeyPairCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportKeyPairCommandInput} for command's `input` shape.
- * @see {@link ImportKeyPairCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportKeyPairCommand extends $Command<ImportKeyPairCommandInput, ImportKeyPairCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ImportKeyPairCommandInput;
     constructor(input: ImportKeyPairCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportKeyPairCommandInput, ImportKeyPairCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ImportSnapshotCommandInput extends ImportSnapshotRequest {
 }
 export interface ImportSnapshotCommandOutput extends ImportSnapshotResult, __MetadataBearer {
 }
-/**
- * <p>Imports a disk into an EBS snapshot.</p>
- *          <p>For more information, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-import-snapshot.html">Importing a disk as a snapshot using VM Import/Export</a> in the
- *    <i>VM Import/Export User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ImportSnapshotCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ImportSnapshotCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ImportSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportSnapshotCommandInput} for command's `input` shape.
- * @see {@link ImportSnapshotCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportSnapshotCommand extends $Command<ImportSnapshotCommandInput, ImportSnapshotCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ImportSnapshotCommandInput;
     constructor(input: ImportSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportSnapshotCommandInput, ImportSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ImportVolumeCommandInput extends ImportVolumeRequest {
 }
 export interface ImportVolumeCommandOutput extends ImportVolumeResult, __MetadataBearer {
 }
-/**
- * <p>Creates an import volume task using metadata from the specified disk image.</p>
- *          <p>This API action supports only single-volume VMs. To import multi-volume VMs, use
- *    <a>ImportImage</a> instead. To import a disk to a snapshot, use
- *    <a>ImportSnapshot</a> instead.</p>
- *          <p>This API action is not supported by the Command Line Interface (CLI). For
- *    information about using the Amazon EC2 CLI, which is deprecated, see <a href="https://awsdocs.s3.amazonaws.com/EC2/ec2-clt.pdf#importing-your-volumes-into-amazon-ebs">Importing Disks to Amazon EBS</a> in the <i>Amazon EC2 CLI Reference</i> PDF file.</p>
- *          <p>For information about the import manifest referenced by this API action, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM Import Manifest</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ImportVolumeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ImportVolumeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ImportVolumeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ImportVolumeCommandInput} for command's `input` shape.
- * @see {@link ImportVolumeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ImportVolumeCommand extends $Command<ImportVolumeCommandInput, ImportVolumeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ImportVolumeCommandInput;
     constructor(input: ImportVolumeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportVolumeCommandInput, ImportVolumeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ModifyAddressAttributeCommandInput extends ModifyAddressAttribu
 }
 export interface ModifyAddressAttributeCommandOutput extends ModifyAddressAttributeResult, __MetadataBearer {
 }
-/**
- * <p>Modifies an attribute of the specified Elastic IP address. 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, ModifyAddressAttributeCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyAddressAttributeCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyAddressAttributeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyAddressAttributeCommandInput} for command's `input` shape.
- * @see {@link ModifyAddressAttributeCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyAddressAttributeCommand extends $Command<ModifyAddressAttributeCommandInput, ModifyAddressAttributeCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyAddressAttributeCommandInput;
     constructor(input: ModifyAddressAttributeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyAddressAttributeCommandInput, ModifyAddressAttributeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ModifyAvailabilityZoneGroupCommandInput extends ModifyAvailabil
 }
 export interface ModifyAvailabilityZoneGroupCommandOutput extends ModifyAvailabilityZoneGroupResult, __MetadataBearer {
 }
-/**
- * <p>Changes the opt-in status of the Local Zone and Wavelength Zone group for your
- *       account.</p>
- *          <p>Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html">
- *   		DescribeAvailabilityZones</a> to view the value for <code>GroupName</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyAvailabilityZoneGroupCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyAvailabilityZoneGroupCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyAvailabilityZoneGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyAvailabilityZoneGroupCommandInput} for command's `input` shape.
- * @see {@link ModifyAvailabilityZoneGroupCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyAvailabilityZoneGroupCommand extends $Command<ModifyAvailabilityZoneGroupCommandInput, ModifyAvailabilityZoneGroupCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyAvailabilityZoneGroupCommandInput;
     constructor(input: ModifyAvailabilityZoneGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyAvailabilityZoneGroupCommandInput, ModifyAvailabilityZoneGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ModifyCapacityReservationCommandInput extends ModifyCapacityRes
 }
 export interface ModifyCapacityReservationCommandOutput extends ModifyCapacityReservationResult, __MetadataBearer {
 }
-/**
- * <p>Modifies a Capacity Reservation's capacity and the conditions under which it is to be released. You
- * 			cannot change a Capacity Reservation's instance type, EBS optimization, instance store settings,
- * 			platform, Availability Zone, or instance eligibility. If you need to modify any of these
- * 			attributes, we recommend that you cancel the Capacity Reservation, and then create a new one with
- * 			the required attributes.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyCapacityReservationCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyCapacityReservationCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyCapacityReservationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyCapacityReservationCommandInput} for command's `input` shape.
- * @see {@link ModifyCapacityReservationCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyCapacityReservationCommand extends $Command<ModifyCapacityReservationCommandInput, ModifyCapacityReservationCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyCapacityReservationCommandInput;
     constructor(input: ModifyCapacityReservationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyCapacityReservationCommandInput, ModifyCapacityReservationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ModifyCapacityReservationFleetCommandInput extends ModifyCapaci
 }
 export interface ModifyCapacityReservationFleetCommandOutput extends ModifyCapacityReservationFleetResult, __MetadataBearer {
 }
-/**
- * <p>Modifies a Capacity Reservation Fleet.</p>
- * 		       <p>When you modify the total target capacity of a Capacity Reservation Fleet, the Fleet automatically
- * 			creates new Capacity Reservations, or modifies or cancels existing Capacity Reservations in the Fleet
- * 			to meet the new total target capacity. When you modify the end date for the Fleet, the end dates for
- * 			all of the individual Capacity Reservations in the Fleet are updated accordingly.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EC2Client, ModifyCapacityReservationFleetCommand } from "@aws-sdk/client-ec2"; // ES Modules import
- * // const { EC2Client, ModifyCapacityReservationFleetCommand } = require("@aws-sdk/client-ec2"); // CommonJS import
- * const client = new EC2Client(config);
- * const command = new ModifyCapacityReservationFleetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ModifyCapacityReservationFleetCommandInput} for command's `input` shape.
- * @see {@link ModifyCapacityReservationFleetCommandOutput} for command's `response` shape.
- * @see {@link EC2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ModifyCapacityReservationFleetCommand extends $Command<ModifyCapacityReservationFleetCommandInput, ModifyCapacityReservationFleetCommandOutput, EC2ClientResolvedConfig> {
     readonly input: ModifyCapacityReservationFleetCommandInput;
     constructor(input: ModifyCapacityReservationFleetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EC2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ModifyCapacityReservationFleetCommandInput, ModifyCapacityReservationFleetCommandOutput>;
     private serialize;
     private deserialize;